<Types>

<Type>

<Name>System.Management.Automation.AliasInfo</Name>

<Members>

<AliasProperty>

<Name>Namespace</Name>

<ReferencedMemberName>CommandNamespace</ReferencedMemberName>

</AliasProperty>

</Members>

</Type>

<Type>

<Name>System.Management.Automation.ApplicationInfo</Name>

<Members>

<AliasProperty>

<Name>Namespace</Name>

<ReferencedMemberName>CommandNamespace</ReferencedMemberName>

</AliasProperty>

<ScriptProperty>

<Name>Root</Name>

<GetScriptBlock>

if ($this.'.Root') {

return $this.'.Root'

}

$nextRoot = $this.Source | Split-Path

:findingRoot do {

$lastRoot = $nextRoot

$lastRootName = $lastRoot | Split-Path -Leaf

if ($lastRootName -as [Version]) {

$lastRootName = $lastRoot | Split-Path | Split-Path -Leaf

}

foreach ($fileNameThatIndicatesRoot in 'LICENSE', 'LICENSE.txt',

"$LastRootName.psd1", "$LastRootName.psm1", ".git") {

$lookingForPath = Join-Path $lastRoot $fileNameThatIndicatesRoot

if (Test-Path $lookingForPath) {

break findingRoot

}

}

$nextRoot = $nextRoot | Split-Path

} while ($nextRoot)

$this | Add-Member NoteProperty '.Root' "$lastRoot" -Force

$this.'.Root'

</GetScriptBlock>

<SetScriptBlock>

$this | Add-Member NoteProperty ".Root" $args -Force

</SetScriptBlock>

</ScriptProperty>

</Members>

</Type>

<Type>

<Name>System.Management.Automation.Language.Ast</Name>

<Members>

<AliasProperty>

<Name>GetCollectionAndIndex</Name>

<ReferencedMemberName>GetRelativeIndex</ReferencedMemberName>

</AliasProperty>

<ScriptMethod>

<Name>ConvertFromAST</Name>

<Script>

param()

return $this

</Script>

</ScriptMethod>

<ScriptMethod>

<Name>FirstElements</Name>

<Script>

&lt;#

.SYNOPSIS

Gets the First N elements in an AST

.DESCRIPTION

Gets the First N elements within an AST, excluding this element.

#&gt;

param(

# The number of elements to get. By default, one.

[int]

$NumberOfElements = 1

)

$foundElementCount = 0

foreach ($foundElement in $this.FindAll({$true}, $true)) {

if (-not $foundElementCount) {

$foundElementCount++

continue

}

# We want to skip named blocks in this case, as we're really after the first "real" element.

if ($foundElement -is [Management.Automation.Language.NamedBlockAst]) {

continue

}

if ($foundElementCount -le $NumberOfElements) {

$foundElementCount++

$foundElement

} else {

break

}

}

</Script>

</ScriptMethod>

<ScriptMethod>

<Name>GetLineage</Name>

<Script>

&lt;#

.SYNOPSIS

Gets AST Lineage

.DESCRIPTION

Gets the Lineage of an Abstract Syntax Tree element.

The Lineage is all of the Abstract Syntax Tree's parents.

#&gt;

$thisParent = $this.Parent

while ($thisParent) {

$thisParent

$thisParent = $thisParent.Parent

}

</Script>

</ScriptMethod>

<ScriptMethod>

<Name>GetRelativeIndex</Name>

<Script>

$thisCollection,$thisIndex = $null,-1

:FindThisIndex foreach ($parentProperty in $this.Parent.psobject.Properties) {

if ($parentProperty -is [PSScriptProperty] -or $parentProperty -is [PSNoteProperty]) {

continue FindThisIndex

}

$currentProperty = $this.Parent.($parentProperty.Name)

if (-not $currentProperty.IndexOf) { continue }

if ($currentProperty.IndexOf($this) -ge 0) {

$thisCollection = $currentProperty

$thisIndex = $thisCollection.IndexOf($this)

break FindThisIndex

}

}

return ([PSCustomObject][Ordered]@{

Collection = $thisCollection

Index = $thisIndex

})

</Script>

</ScriptMethod>

<ScriptMethod>

<Name>IsEquivalentTo</Name>

<Script>

&lt;#

.SYNOPSIS

Attempts to Determine Ast Equivalence

.DESCRIPTION

Attempts to Determine if `$this` Ast element is the same as some `$Other` object.

If `$Other is a `[string]`, it will be converted into a `[ScriptBlock]`

If `$Other is a `[ScriptBlock]`, it will become the `[ScriptBlock]`s AST

If the types differ, `$other is not equivalent to `$this.

If the content is the same with all whitespace removed, it will be considered equivalent.

.NOTES

Due to the detection mechanism, IsEquivalentTo will consider strings with whitespace changes equivalent.

#&gt;

param(

# The other item.

$Other

)

if (-not $other) { return $false }

if ($other -is [string]) {

$other = [ScriptBlock]::Create($other).Ast

}

if ($other -is [scriptblock]) {

$other = $Other.Ast

}

if ($other -isnot [Management.Automation.Language.Ast]) {

return $false

}

if ($other.GetType() -ne $this.GetType()) { return $false }

# We're going to start off very easy, and slightly incorrect:

($this -replace '[\s\r\n]') -eq ($other -replace '[\s\r\n]')

# (There are many cases where, say, variable renames would be innocuous, but that's a rabbit hole of variable detection. The same is true of commands.)

# However, in 98% of cases, two scriptblocks without whitespace that are the same are equivalent. The exception to the rule: whitespace within strings.

</Script>

</ScriptMethod>

<ScriptMethod>

<Name>Transpile</Name>

<Script>

[ScriptBlock]::Create(

"$this"

) | .&gt;PipeScript

</Script>

</ScriptMethod>

<ScriptProperty>

<Name>ByType</Name>

<GetScriptBlock>

&lt;#

.SYNOPSIS

Gets PowerShell AST Nodes by type

.DESCRIPTION

Gets a dictionary of all nodes in a PowerShell AST beneath this point, grouped by type.

.EXAMPLE

{"hello world"}.Ast.ByType

#&gt;

if (-not $this.'.ByType') {

$ByType = [Collections.Generic.Dictionary[Type,Collections.Generic.List[PSObject]]]::new()

foreach ($node in $this.FindAll({$true}, $true)) {

$nodeType = $node.GetType()

if (-not $ByType[$nodeType]) {

$ByType[$nodeType] = [Collections.Generic.List[PSObject]]::new()

}

$ByType[$nodeType].Add($node)

}

Add-Member -InputObject $this -MemberType NoteProperty -Name '.ByType' -Value $ByType -Force

}

$this.'.ByType'

</GetScriptBlock>

</ScriptProperty>

<ScriptProperty>

<Name>Commands</Name>

<GetScriptBlock>

&lt;#

.SYNOPSIS

Gets all Commands within an AST

.DESCRIPTION

Gets all Command references within a PowerShell Abstract Syntax Tree

.EXAMPLE

{Get-Process}.Ast.Commands

#&gt;

,@(foreach ($node in $this.ByType[[Management.Automation.Language.CommandAST]]) {

$node

})

</GetScriptBlock>

</ScriptProperty>

<ScriptProperty>

<Name>Defines</Name>

<GetScriptBlock>

&lt;#

.SYNOPSIS

Gets all Definitions within an AST

.DESCRIPTION

Gets all Function and Type Definitions and Parameters within a PowerShell Abstract Syntax Tree

.EXAMPLE

{function foo() { "foo"} class bar { $bar = "none"} }.Ast.Defines

#&gt;

, @(

foreach ($node in $this.ByType[@(

[Management.Automation.Language.FunctionDefinitionAst]

[Management.Automation.Language.TypeDefinitionAst]

[Management.Automation.Language.ParameterAst]

)]) {

$node

}

)

</GetScriptBlock>

</ScriptProperty>

<ScriptProperty>

<Name>First</Name>

<GetScriptBlock>

&lt;#

.SYNOPSIS

Gets the first nested AST

.DESCRIPTION

Gets the first nested element of this AST

.EXAMPLE

{

do { } while ($false)

}.First

#&gt;

param()

$this.FirstElements(1)

</GetScriptBlock>

</ScriptProperty>

<ScriptProperty>

<Name>IsEmpty</Name>

<GetScriptBlock>

&lt;#

.SYNOPSIS

Determines if a PowerShell AST is empty

.DESCRIPTION

Determines if a PowerShell Abstract Syntax Tree is empty.

It will be considered empty if is a ScriptBlockExpression with no parameters or statements in any blocks.

#&gt;

param()

$ast = $this

if ($ast.Body) {

$ast = $ast.Body

}

if ($ast -isnot [Management.Automation.Language.ScriptBlockExpressionAST]) {

return $false

}

foreach ($property in $ast.psobject.Properties) {

if ($property.Name -notmatch 'Block$') { continue }

if ($property.Value.Statements.Count) { return $false }

if ($property.Value.Parameters.Count) { return $false }

}

return $true

</GetScriptBlock>

</ScriptProperty>

<ScriptProperty>

<Name>Tokens</Name>

<GetScriptBlock>

$text = $this.Extent.ToString()

$previousToken = $null

$tokenCount = 0

@(foreach ($token in [Management.Automation.PSParser]::Tokenize($text, [ref]$null)) {

Add-Member NoteProperty Text $text -Force -InputObject $token

Add-Member NoteProperty PreviousToken $previousToken -Force -InputObject $token

if ($token.Type -in 'Variable', 'String') {

$realContent = $text.Substring($token.Start, $token.Length)

Add-Member NoteProperty Content $realContent -Force -InputObject $token

}

$previousToken = $token

$tokenCount++

$token

})

</GetScriptBlock>

</ScriptProperty>

<ScriptProperty>

<Name>Transpilers</Name>

<GetScriptBlock>

$scriptText = $this.Extent.ToString()

# If the ScriptBlock had attributes, we'll add them to a special list of things that will be transpiled first.

# Find all AST elements within the script block.

$astList = @($this.FindAll({$true}, $false))

# At various points within transpilation, we will be skipping processing until a known end pointer. For now, set this to null.

$skipUntil = 0

# Keep track of the offset from a starting position as well, for the same reason.

$myOffset = 0

# Walk over each item in the abstract syntax tree.

:NextAstItem foreach ($item in $astList) {

# If skipUntil was set,

if ($skipUntil) {

# find the space between now and the last known offset.

try {

$newOffset = $scriptText.IndexOf($item.Extent.Text, $myOffset)

if ($newOffset -eq -1) { continue }

$myOffset = $newOffset

} catch {

$ex =$_

$null = $null

}

if ($myOffset -lt $skipUntil) { # If this is before our skipUntil point

continue # ignore this AST element.

}

$skipUntil = $null # If we have reached our skipUntil point, let's stop skipping.

}

# otherwise, find if any pipescripts match this AST

$foundTranspilers = Get-Transpiler -CouldPipe $item -ValidateInput $item

if ($foundTranspilers) {

foreach ($transpiler in $foundTranspilers) {

[PSCustomObject][Ordered]@{

PSTypeName = 'PipeScript.Transpiler.Location'

Transpiler =

if ($Transpiler.ExtensionInputObject.ResolvedCommand) {

@($Transpiler.ExtensionInputObject.ResolvedCommand) -ne $null

} else {

$Transpiler.ExtensionCommand

}

AST = $item

}

}

$start = $scriptText.IndexOf($item.Extent.Text, $myOffset) # determine the end of this AST element

$end = $start + $item.Extent.Text.Length

$skipUntil = $end # set SkipUntil

}

}

</GetScriptBlock>

</ScriptProperty>

<ScriptProperty>

<Name>Trivia</Name>

<GetScriptBlock>

&lt;#

.SYNOPSIS

Gets an AST's Trivia

.DESCRIPTION

Gets an AST's Trivia. This is any documentation directly before this ast element.

#&gt;

param()

if (-not $this.Parent) { return }

$relativeIndex = $this.GetRelativeIndex()

if (-not $relativeIndex.Collection) { return }

$thisCollection = $relativeIndex.Collection

$thisIndex = $relativeIndex.Index

# For the first parameter,

if ($thisIndex -eq 0) {

$parentExtent = $this.Parent.Extent.ToString()

# this starts after the first parenthesis (if present)

$afterFirstParens = $parentExtent.IndexOf('(') + 1

# and goes until the start of the parameter

$parentExtent.Substring($afterFirstParens,

$this.Extent.StartOffset -

$this.Parent.Extent.StartOffset -

$afterFirstParens) -replace '^[\s\r\n]+'

# (don't forget to trim leading whitespace).

} else {

# For every other parameter it is the content between parameters.

$lastItem = $thisCollection[$thisIndex - 1]

$relativeOffset = $lastItem.Extent.EndOffset + 1 - $this.Parent.Extent.StartOffset

$distance = $this.Extent.StartOffset - $lastItem.Extent.EndOffset - 1

# (don't forget to trim leading whitespace and commas)

$this.Parent.Extent.ToString().Substring($relativeOffset,$distance) -replace '^[\,\s\r\n]+'

}

</GetScriptBlock>

</ScriptProperty>

<ScriptProperty>

<Name>Types</Name>

<GetScriptBlock>

&lt;#

.SYNOPSIS

Gets all Types within an AST

.DESCRIPTION

Gets all Types referenced within a PowerShell Abstract Syntax Tree

.EXAMPLE

{[int];[psobject];[xml]}.Ast.Types

#&gt;

,@(foreach ($node in $this.ByType[[Management.Automation.Language.TypeExpressionAst]]) {

$node

})

</GetScriptBlock>

</ScriptProperty>

<ScriptProperty>

<Name>Unique</Name>

<GetScriptBlock>

&lt;#

.SYNOPSIS

Gets unique AST elements

.DESCRIPTION

Gets unique AST elements. Uniqueness is defined by being literally the same text.

#&gt;

$uniqueElements = [Ordered]@{}

foreach ($foundElement in @($this.FindAll({$true},$true))) {

if ($uniqueElements["$foundElement"]) {

continue

}

$uniqueElements["$foundElement"] = $foundElement

}

@($uniqueElements.Values)

</GetScriptBlock>

</ScriptProperty>

<ScriptProperty>

<Name>Variables</Name>

<GetScriptBlock>

&lt;#

.SYNOPSIS

Gets all Variables within an AST

.DESCRIPTION

Gets all Variable references within a PowerShell Abstract Syntax Tree

.EXAMPLE

{$x, $y, $z}.Ast.Variables

#&gt;

, @(foreach ($node in $this.ByType[[Management.Automation.Language.VariableExpressionAst]]) {

$node

})

</GetScriptBlock>

</ScriptProperty>

</Members>

</Type>

<Type>

<Name>System.Management.Automation.Language.AttributeAst</Name>

<Members>

<AliasProperty>

<Name>Args</Name>

<ReferencedMemberName>ArgumentList</ReferencedMemberName>

</AliasProperty>

<AliasProperty>

<Name>Arguments</Name>

<ReferencedMemberName>ArgumentList</ReferencedMemberName>

</AliasProperty>

<AliasProperty>

<Name>Parameters</Name>

<ReferencedMemberName>Parameter</ReferencedMemberName>

</AliasProperty>

<ScriptProperty>

<Name>ArgumentList</Name>

<GetScriptBlock>

$Parameter = [Ordered]@{}

$ArgumentList = @()

# Collect all of the arguments of the attribute, in the order they were specified.

$argsInOrder = @(

@($this.PositionalArguments) + @($this.NamedArguments) |

Sort-Object { $_.Extent.StartOffset}

)

# Now we need to map each of those arguments into either named or positional arguments.

foreach ($attributeArg in $argsInOrder) {

# Named arguments are fairly straightforward:

if ($attributeArg -is [Management.Automation.Language.NamedAttributeArgumentAst]) {

$argName = $attributeArg.ArgumentName

$argAst = $attributeArg.Argument

$parameter[$argName] =

if ($argName -eq $argAst) { # If the argument is the name,

$true # treat it as a [switch] parameter.

}

# If the argument value was an ScriptBlockExpression

else {

$argAst

}

} else {

# If we are a positional parameter, for the moment:

if ($parameter.Count) {

# add it to the last named parameter.

$parameter[@($parameter.Keys)[-1]] =

@() + $parameter[@($parameter.Keys)[-1]] + $argAst

} else {

# Or add it to the list of string arguments.

$ArgumentList +=

$attributeArg.ConvertFromAst()

}

}

}

return $ArgumentList

</GetScriptBlock>

</ScriptProperty>

<ScriptProperty>

<Name>Parameter</Name>

<GetScriptBlock>

&lt;#

.SYNOPSIS

Gets the parameters of an attribute

.DESCRIPTION

Gets the named parameters of an attribute.

.EXAMPLE

{

[AnAttribute(Parameter='Value')]$null

}.Ast.EndBlock.Statements[0].PipelineElements[0].Expression.Attribute.Parameters

#&gt;

$Parameter = [Ordered]@{}

# Collect all of the arguments of the attribute, in the order they were specified.

$argsInOrder = @(

@($this.PositionalArguments) + @($this.NamedArguments) |

Sort-Object { $_.Extent.StartOffset}

)

# Now we need to map each of those arguments into either named or positional arguments.

foreach ($attributeArg in $argsInOrder) {

# Named arguments are fairly straightforward:

if ($attributeArg -is [Management.Automation.Language.NamedAttributeArgumentAst]) {

$argName = $attributeArg.ArgumentName

$argAst = $attributeArg.Argument

$parameter[$argName] =

if ($argName -eq $argAst) { # If the argument is the name,

$true # treat it as a [switch] parameter.

}

# If the argument value was an ScriptBlockExpression

else {

$argAst.ConvertFromAst()

}

} else {

# If we are a positional parameter, for the moment:

if ($parameter.Count) {

# add it to the last named parameter.

$parameter[@($parameter.Keys)[-1]] =

@() + $parameter[@($parameter.Keys)[-1]] + $attributeArg.ConvertFromAst()

}

}

}

return $Parameter

</GetScriptBlock>

</ScriptProperty>

<ScriptProperty>

<Name>ResolvedCommand</Name>

<GetScriptBlock>

&lt;#

.SYNOPSIS

Resolves an Attribute to a CommandInfo

.DESCRIPTION

Resolves an Attribute to one or more CommandInfo.

.EXAMPLE

{

[InvokePipeScript()]$null

}.Ast.EndBlock.Statements[0].PipelineElements[0].Expression.Attribute.ResolvedCommand

.EXAMPLE

{

[Microsoft.PowerShell.Core.GetCommand()]$null

}.Ast.EndBlock.Statements[0].PipelineElements[0].Expression.Attribute.ResolvedCommand

.EXAMPLE

{

[Get_Command()]$null

}.Ast.EndBlock.Statements[0].PipelineElements[0].Expression.Attribute.ResolvedCommand

.EXAMPLE

{

[GetCommand()]$null

}.Ast.EndBlock.Statements[0].PipelineElements[0].Expression.Attribute.ResolvedCommand

.EXAMPLE

{

[cmd()]$null

}.EndBlock.Statements[0].PipelineElements[0].Expression.Attribute.ResolvedCommand

#&gt;

# Get the name of the transpiler.

$transpilerStepName =

if ($this.TypeName.IsGeneric) {

$this.TypeName.TypeName.Name

} else {

$this.TypeName.Name

}

$decamelCase = [Regex]::new('(?&lt;=[a-z])(?=[A-Z])')

@(

# If a Transpiler exists by that name, it will be returned first.

Get-Transpiler -TranspilerName $transpilerStepName

# Then, any periods in the attribute name will be converted to slashes,

$fullCommandName = $transpilerStepName -replace '\.','\' -replace

'_','-' # and any underscores to dashes.

# Then, the first CamelCased code will have a - injected in between the CamelCase.

$fullCommandName = $decamelCase.Replace($fullCommandName, '-', 1)

# Now we will try to find the command.

$ExecutionContext.SessionState.InvokeCommand.GetCommand($fullCommandName, 'All')

)

</GetScriptBlock>

</ScriptProperty>

</Members>

</Type>

<Type>

<Name>AutomaticVariable.Command</Name>

<Members>

<ScriptProperty>

<Name>VariableName</Name>

<GetScriptBlock>

&lt;#

.SYNOPSIS

Gets the automatic variable name

.DESCRIPTION

Gets the name of an automatic variable that is defined in an Automatic?Variable* command.

#&gt;

$this -replace '(?&gt;Magic|Automatic)\p{P}Variable\p{P}' -replace

'^(?&gt;PowerShell|PipeScript)' -replace

'^\p{P}' -replace '\p{P}$'

</GetScriptBlock>

</ScriptProperty>

</Members>

</Type>

<Type>

<Name>BuildScript.Command</Name>

<Members>

<ScriptProperty>

<Name>Template</Name>

<GetScriptBlock>

$potentialTemplatePaths =

@(

$this.Source -replace '\.ps1$', '.ps.ps1'

$this.Source -replace '\.ps1$', '.ps1.ps1'

)

foreach ($potentialTemplatePath in $potentialTemplatePaths ) {

if (Test-Path $potentialTemplatePath) {

return (Get-PipeScript -PipeScriptPath $potentialTemplatePath)

}

}

</GetScriptBlock>

</ScriptProperty>

</Members>

</Type>

<Type>

<Name>System.Management.Automation.Language.CommandAst</Name>

<Members>

<AliasProperty>

<Name>Args</Name>

<ReferencedMemberName>ArgumentList</ReferencedMemberName>

</AliasProperty>

<AliasProperty>

<Name>Arguments</Name>

<ReferencedMemberName>ArgumentList</ReferencedMemberName>

</AliasProperty>

<AliasProperty>

<Name>Parameters</Name>

<ReferencedMemberName>Parameter</ReferencedMemberName>

</AliasProperty>

<ScriptMethod>

<Name>AsSentence</Name>

<Script>

&lt;#

.SYNOPSIS

Maps Natural Language Syntax to PowerShell Parameters

.DESCRIPTION

Maps a statement in natural language syntax to a set of PowerShell parameters.

All parameters will be collected.

For the purposes of natural language processing ValueFromPipeline will be ignored.

The order the parameters is declared takes precedence over Position attributes.

.NOTES

Each potential command can be thought of as a simple sentence with (mostly) natural syntax

command &lt;parametername&gt; ...&lt;parameterargument&gt; (etc)

either more natural or PowerShell syntax should be allowed, for example:

~~~PowerShell

all functions can Quack {

"quack"

}

~~~

would map to the command all and the parameters -Function and -Can (with the arguments Quack and {"quack"})

Assuming -Functions was a `[switch]` or an alias to a `[switch]`, it will match that `[switch]` and only that switch.

If -Functions was not a `[switch]`, it will match values from that point.

If the parameter type is not a list or PSObject, only the next parameter will be matched.

If the parameter type *is* a list or an PSObject,

or ValueFromRemainingArguments is present and no named parameters were found,

then all remaining arguments will be matched until the next named parameter is found.

_Aliasing is important_ when working with a given parameter.

The alias, _not_ the parameter name, will be what is mapped in .Parameters.

#&gt;

param()

# Because we want to have flexible open-ended arguments here, we do not hard-code any arguments:

# we parse them.

# We're trying to determine:

# Was it right to left?

$IsRightToLeft = $false

# Are there specific commands it might be?

$SpecificCommands = @()

# If so, what are their names?

$specificCommandNames = @()

# We want to start after the first element by default

$startingElementIndex = 1

for ($argIndex =0 ; $argIndex -lt $args.Count; $argIndex++) {

$arg = $args[$argIndex]

# If the argument was an int and greater than one

if ($arg -is [int] -and $arg -gt 1) {

$startingElementIndex = $arg # start parsing that many words in (#479).

continue

}

$commandInfos = $arg -as [Management.Automation.CommandInfo[]]

if ($commandInfos) {

foreach ($cmdInfo in $commandInfos) {

$SpecificCommands += $cmdInfo

$specificCommandNames += $cmdInfo.Name

}

continue

}

if ($arg -match '^[-/]{0,2}(?:Is)?RightToLeft$') {

# If -RightToLeft was passed

$IsRightToLeft = $true

continue

}

$argCommands = @(

$foundTranspiler = Get-Transpiler -TranspilerName $arg

if ($foundTranspiler) {

foreach ($transpiler in $foundTranspiler) {

if ($transpiler.Validate($arg)) {

$transpiler

}

}

} else {

$ExecutionContext.SessionState.InvokeCommand.GetCommands($arg, 'All', $true)

}

)

if ($argCommands) {

$SpecificCommands += $argCommands

continue

}

}

$mappedParameters = [Ordered]@{}

$sentence = [Ordered]@{

PSTypeName='PipeScript.Sentence'

Command = $null

}

$commandAst = $this

$commandElements = @($commandAst.CommandElements)

# If we are going right to left, reverse the command elements

if ($IsRightToLeft) {

[Array]::Reverse($commandElements)

}

$commandElements = # Walk thru each command element

@(foreach ($element in $commandElements) {

# If the element is an array literal, expand it

if ($element -is [Management.Automation.Language.ArrayLiteralAst]) {

$element.Elements

} else {

# otherwise, include it as is.

$element

}

})

# Now we have all of the words in a sentence.

# We can still determine if an item in a list was in a list by inspecting it's parent.

$sentences = @()

if ($SpecificCommands) {

$potentialCommands = $SpecificCommands

$potentialCommandNames = @($SpecificCommands | Select-Object -ExpandProperty Name)

} else {

# The first command element should be the name of the command.

$firstCommandElement = $commandElements[0]

$commandName = ''

$potentialCommandNames = @()

$potentialCommands =

@(

if ($firstCommandElement.Value -and $firstCommandElement.StringConstantType -eq 'BareWord') {

$commandName = $firstCommandElement.Value

$foundTranspiler = Get-Transpiler -TranspilerName $commandName

if ($foundTranspiler) {

foreach ($transpiler in $foundTranspiler) {

if ($transpiler.Validate($commandAst)) {

$potentialCommandNames += $commandName

$transpiler

}

}

} else {

foreach ($foundCmd in $ExecutionContext.SessionState.InvokeCommand.GetCommands($commandName, 'All', $true)) {

$foundCmd

$potentialCommandNames += $commandName

}

}

})

if (-not $potentialCommands) {

[PSCustomObject][Ordered]@{

PSTypeName = 'PipeScript.Sentence'

Keyword = ''

Command = $null

Arguments = $commandElements[0..$commandElements.Length]

}

}

}

$mappedParameters = [Ordered]@{}

if (-not $Script:SentenceWordCache) {

$Script:SentenceWordCache = @{}

}

$potentialCommandIndex = -1

:nextPotentialCommand foreach ($potentialCommand in $potentialCommands) {

$potentialCommandIndex++

$commandName = $potentialCommandName = $potentialCommandNames[$potentialCommandIndex]

# To save time, generate a map of all potential bareword aliases for this command.

$potentialCommandBarewordMap = [Ordered]@{}

foreach ($parameterInfo in $potentialCommand.Parameters.Values) {

$potentialCommandBarewordMap[$parameterInfo.Name] = $parameterInfo

if ($parameterInfo.Aliases) {

foreach ($aliasName in $parameterInfo.Aliases) {

$potentialCommandBarewordMap[$aliasName] = $parameterInfo

}

}

}

# Cache the potential parameters

$potentialParameters = $potentialCommand.Parameters

# Assume the current parameter is empty,

$currentParameter = ''

# the current parameter metadata is null,

$currentParameterMetadata = $null

# there is no current clause,

$currentClause = @()

# and there are no unbound parameters.

$unboundParameters = @()

$clauses = @()

# Walk over each command element in a for loop (we may adjust the index when we match)

for ($commandElementIndex = $startingElementIndex ;$commandElementIndex -lt $commandElements.Count; $commandElementIndex++) {

$commandElement = $CommandElements[$commandElementIndex]

# by default, we assume we haven't found a parameter.

$parameterFound = $false

$barewordSequenece =

@(for ($cei = $commandElementIndex; $cei -lt $commandElements.Count; $cei++) {

if (

$commandElements[$cei] -isnot [Management.Automation.Language.StringConstantExpressionAst] -or

$commandElements[$cei].StringConstantType -ne 'Bareword'

) { break }

$commandElements[$cei].Value

})

# That assumption is quickly challenged if the AST type was CommandParameter

if ($commandElement -is [Management.Automation.Language.CommandParameterAst]) {

# If there were already clauses, finalize them before we start this clause

if ($currentClause) {

$clauses += [PSCustomObject][Ordered]@{

PSTypeName = 'PipeScript.Sentence.Clause'

Name = if ($currentParameter) { $currentParameter} else { '' }

ParameterName = if ($currentParameterMetadata) { $currentParameterMetadata.Name } else { '' }

Words = $currentClause

}

}

$commandParameter = $commandElement

# In that case, we know the name they want to use for the parameter

$currentParameter = $commandParameter.ParameterName

$currentClause = @($currentParameter)

$currentClauseValues = @()

# We need to get the parameter metadata as well.

$currentParameterMetadata =

# If it was the real name of a parameter, this is easy

if ($potentialCommand.Parameters[$currentParameter]) {

$potentialCommand.Parameters[$currentParameter]

$parameterFound = $true

}

else {

# Otherwise, we need to search each parameter for aliases.

foreach ($cmdParam in $potentialCommand.Parameters.Values) {

if ($cmdParam.Aliases -contains $currentParameter) {

$parameterFound = $true

$cmdParam

break

}

}

}

# If the parameter had an argument

if ($commandParameter.Argument) {

# Use that argument

if ($mappedParameters[$currentParameter]) {

$mappedParameters[$currentParameter] = @($mappedParameters[$currentParameter]) + @(

$commandParameter.Argument

)

} else {

$mappedParameters[$currentParameter] = $commandParameter.Argument

}

# and move onto the next element.

$clauses += [PSCustomObject][Ordered]@{

PSTypeName = 'PipeScript.Sentence.Clause'

Name = if ($currentParameter) { $currentParameter} else { '' }

ParameterName = if ($currentParameterMetadata) { $currentParameterMetadata.Name } else { '' }

Words = $currentClause

ParameterValues = @($commandParameter.Argument)

}