deps: update acorn-walk to 8.3.0

PR-URL: #50457 Reviewed-By: Mohammed Keyvanzadeh <[email protected]> Reviewed-By: Moshe Atlow <[email protected]> Reviewed-By: Luigi Pinca <[email protected]> Reviewed-By: Marco Ippolito <[email protected]>

Author: nodejs-github-bot

deps/acorn/acorn-walk/CHANGELOG.md

@@ -1,3 +1,9 @@
+## 8.3.0 (2023-10-26)
+
+### New features
+
+Use a set of new, much more precise, TypeScript types.
+
 ## 8.2.0 (2021-09-06)
 
 ### New features

deps/acorn/acorn-walk/README.md

@@ -10,9 +10,7 @@ Acorn is open source software released under an
 
 You are welcome to
 [report bugs](https://github.com/acornjs/acorn/issues) or create pull
-requests on [github](https://github.com/acornjs/acorn). For questions
-and discussion, please use the
-[Tern discussion forum](https://discuss.ternjs.net).
+requests on [github](https://github.com/acornjs/acorn).
 
 ## Installation
 
@@ -68,7 +66,7 @@ const acorn = require("acorn")
 constwalk=require("acorn-walk")
 
 walk.ancestor(acorn.parse("foo('hi')"),{
-Literal(_, ancestors){
+Literal(_node, _state, ancestors){
 console.log("This literal's ancestors are:", ancestors.map(n=>n.type))
  }
 })

deps/acorn/acorn-walk/dist/walk.d.mts

@@ -0,0 +1,170 @@
+import*asacornfrom"acorn"
+
+exporttypeFullWalkerCallback<TState>=(
+node: acorn.Node,
+state: TState,
+type: string
+)=>void
+
+exporttypeFullAncestorWalkerCallback<TState>=(
+node: acorn.Node,
+state: TState,
+ancestors: acorn.Node[],
+type: string
+)=>void
+
+typeAggregateType={
+Expression: acorn.Expression,
+Statement: acorn.Statement,
+Pattern: acorn.Pattern,
+ForInit: acorn.VariableDeclaration|acorn.Expression
+}
+
+exporttypeSimpleVisitors<TState>={
+[typeinacorn.AnyNode["type"]]?: (node: Extract<acorn.AnyNode,{type: type}>,state: TState)=>void
+}&{
+[typeinkeyofAggregateType]?: (node: AggregateType[type],state: TState)=>void
+}
+
+exporttypeAncestorVisitors<TState>={
+[typeinacorn.AnyNode["type"]]?: (node: Extract<acorn.AnyNode,{type: type}>,state: TState,ancestors: acorn.Node[]
+)=>void
+}&{
+[typeinkeyofAggregateType]?: (node: AggregateType[type],state: TState,ancestors: acorn.Node[])=>void
+}
+
+exporttypeWalkerCallback<TState>=(node: acorn.Node,state: TState)=>void
+
+exporttypeRecursiveVisitors<TState>={
+[typeinacorn.AnyNode["type"]]?: (node: Extract<acorn.AnyNode,{type: type}>,state: TState,callback: WalkerCallback<TState>)=>void
+}&{
+[typeinkeyofAggregateType]?: (node: AggregateType[type],state: TState,callback: WalkerCallback<TState>)=>void
+}
+
+exporttypeFindPredicate=(type: string,node: acorn.Node)=>boolean
+
+exportinterfaceFound<TState>{
+node: acorn.Node,
+state: TState
+}
+
+/**
+ * does a 'simple' walk over a tree
+ * @param node the AST node to walk
+ * @param visitors an object with properties whose names correspond to node types in the{@link https://github.com/estree/estree | ESTree spec}. The properties should contain functions that will be called with the node object and, if applicable the state at that point.
+ * @param base a walker algorithm
+ * @param state a start state. The default walker will simply visit all statements and expressions and not produce a meaningful state. (An example of a use of state is to track scope at each point in the tree.)
+ */
+exportfunctionsimple<TState>(
+node: acorn.Node,
+visitors: SimpleVisitors<TState>,
+base?: RecursiveVisitors<TState>,
+state?: TState
+): void
+
+/**
+ * does a 'simple' walk over a tree, building up an array of ancestor nodes (including the current node) and passing the array to the callbacks as a third parameter.
+ * @param node 
+ * @param visitors 
+ * @param base 
+ * @param state 
+ */
+exportfunctionancestor<TState>(
+node: acorn.Node,
+visitors: AncestorVisitors<TState>,
+base?: RecursiveVisitors<TState>,
+state?: TState
+): void
+
+/**
+ * does a 'recursive' walk, where the walker functions are responsible for continuing the walk on the child nodes of their target node. 
+ * @param node 
+ * @param state the start state
+ * @param functions contain an object that maps node types to walker functions
+ * @param base provides the fallback walker functions for node types that aren't handled in the{@link functions} object. If not given, the default walkers will be used.
+ */
+exportfunctionrecursive<TState>(
+node: acorn.Node,
+state: TState,
+functions: RecursiveVisitors<TState>,
+base?: RecursiveVisitors<TState>
+): void
+
+/**
+ * does a 'full' walk over a tree, calling the{@link callback} with the arguments (node, state, type) for each node
+ * @param node 
+ * @param callback 
+ * @param base 
+ * @param state 
+ */
+exportfunctionfull<TState>(
+node: acorn.Node,
+callback: FullWalkerCallback<TState>,
+base?: RecursiveVisitors<TState>,
+state?: TState
+): void
+
+/**
+ * does a 'full' walk over a tree, building up an array of ancestor nodes (including the current node) and passing the array to the callbacks as a third parameter.
+ * @param node 
+ * @param callback 
+ * @param base 
+ * @param state 
+ */
+exportfunctionfullAncestor<TState>(
+node: acorn.Node,
+callback: FullAncestorWalkerCallback<TState>,
+base?: RecursiveVisitors<TState>,
+state?: TState
+): void
+
+/**
+ * builds a new walker object by using the walker functions in{@link functions} and filling in the missing ones by taking defaults from{@link base}.
+ * @param functions 
+ * @param base 
+ */
+exportfunctionmake<TState>(
+functions: RecursiveVisitors<TState>,
+base?: RecursiveVisitors<TState>
+): RecursiveVisitors<TState>
+
+/**
+ * tries to locate a node in a tree at the given start and/or end offsets, which satisfies the predicate test.{@link start} and{@link end} can be either `null` (as wildcard) or a `number`.{@link test} may be a string (indicating a node type) or a function that takes (nodeType, node) arguments and returns a boolean indicating whether this node is interesting.{@link base} and{@link state} are optional, and can be used to specify a custom walker. Nodes are tested from inner to outer, so if two nodes match the boundaries, the inner one will be preferred.
+ * @param node 
+ * @param start 
+ * @param end 
+ * @param type 
+ * @param base 
+ * @param state 
+ */
+exportfunctionfindNodeAt<TState>(
+node: acorn.Node,
+start: number|undefined,
+end?: number|undefined,
+type?: FindPredicate|string,
+base?: RecursiveVisitors<TState>,
+state?: TState
+): Found<TState>|undefined
+
+/**
+ * like{@link findNodeAt}, but will match any node that exists 'around' (spanning) the given position.
+ * @param node 
+ * @param start 
+ * @param type 
+ * @param base 
+ * @param state 
+ */
+exportfunctionfindNodeAround<TState>(
+node: acorn.Node,
+start: number|undefined,
+type?: FindPredicate|string,
+base?: RecursiveVisitors<TState>,
+state?: TState
+): Found<TState>|undefined
+
+/**
+ * similar to{@link findNodeAround}, but will match all nodes after the given position (testing outer nodes before inner nodes).
+ */
+exportconstfindNodeAfter: typeoffindNodeAround
+
+exportconstbase: RecursiveVisitors<any>