rreverser

marijn

adrianheine

acorn-walk

Add `Function` and `Class` to the `AggregateType` type, so that they can be used in walkers without raising a type error.

Visitor functions are now called in such a way that their `this` refers to the object they are part of.

Use a set of new, much more precise, TypeScript types.

Add support for walking ES2022 class static blocks.

Support node types for class fields and private methods.

Adjust package.json to work with Node 12.16.0 and 13.0-13.6.

Fix a bug where `full` and `fullAncestor` would skip nodes with overridden types.

The package can now be loaded directly as an ECMAScript module in node 13+.

Support optional chaining and nullish coalescing.

Add support for `export * as ns from "source"`.

Clean up the type definitions to actually work well with the main parser.

Add a TypeScript definition file for the library.

Support walking `ImportExpression` nodes.

The walker now walks `TemplateElement` nodes.

This is now a separate package, `acorn-walk`, rather than part of the main `acorn` package.

The `ScopeBody` and `ScopeExpression` meta-node-types are no longer supported.

Make sure the walker and bin files are rebuilt on release (the previous release didn't get the up-to-date versions).

export type FullWalkerCallback<TState> = (

export type FullAncestorWalkerCallback<TState> = (

  ForInit: acorn.VariableDeclaration | acorn.Expression

  [type in acorn.AnyNode["type"]]?: (node: Extract<acorn.AnyNode, { type: type }>, state: TState) => void

  [type in keyof AggregateType]?: (node: AggregateType[type], state: TState) => void

  [type in acorn.AnyNode["type"]]?: ( node: Extract<acorn.AnyNode, { type: type }>, state: TState, ancestors: acorn.Node[]

  [type in keyof AggregateType]?: (node: AggregateType[type], state: TState, ancestors: acorn.Node[]) => void

export type WalkerCallback<TState> = (node: acorn.Node, state: TState) => void

export type RecursiveVisitors<TState> = {

  [type in acorn.AnyNode["type"]]?: ( node: Extract<acorn.AnyNode, { type: type }>, state: TState, callback: WalkerCallback<TState>) => void

  [type in keyof AggregateType]?: (node: AggregateType[type], state: TState, callback: WalkerCallback<TState>) => void

export type FindPredicate = (type: string, node: acorn.Node) => boolean

 * @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 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.)

 * 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.

 * does a 'recursive' walk, where the walker functions are responsible for continuing the walk on the child nodes of their target node. 

 * @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.

 * does a 'full' walk over a tree, calling the {@link callback} with the arguments (node, state, type) for each node

 * 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.

  callback: FullAncestorWalkerCallback<TState>,

  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :

  typeof define === 'function' && define.amd ? define(['exports'], factory) :

  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory((global.acorn = global.acorn || {}, global.acorn.walk = {})));

})(this, (function (exports) { 'use strict';

  // AST walker module for Mozilla Parser API compatible trees

  // AST walker module for ESTree compatible trees

  // A simple walk is one where you simply specify callbacks to be

  // called on specific nodes. The last two arguments are optional. A

  //         Expression: function(node) { ... }

  // to do something with all expressions. All Parser API node types

  // to do something with all expressions. All ESTree node types

  // can be used to identify node types, as well as Expression and

  // Statement, which denote categories of nodes.

  // The base argument can be used to pass a custom (recursive)

  // walker, and state can be used to give this walked an initial

  function simple(node, visitors, baseVisitor, state, override) {

    if (!baseVisitor) { baseVisitor = base

      var type = override || node.type, found = visitors[type];

      if (visitors[type]) { visitors[type](node, st); }

  // An ancestor walk keeps an array of ancestor nodes (including the

  // current node) and passes them to the callback as third parameter

  // (and also as state parameter when no other state is present).

  function ancestor(node, visitors, baseVisitor, state, override) {

      var isNew = node !== ancestors[ancestors.length - 1];

      if (isNew) { ancestors.push(node); }

      if (found) { found(node, st || ancestors, ancestors); }

      if (visitors[type]) { visitors[type](node, st || ancestors, ancestors); }

  // A recursive walk is one where your functions override the default

  // walkers. They can modify and replace the state parameter that's

  // threaded through the walk, and can opt how and whether to walk

  // their child nodes (by calling their third argument on these

  function recursive(node, state, funcs, baseVisitor, override) {

    var visitor = funcs ? make(funcs, baseVisitor || undefined) : baseVisitor

      visitor[override || node.type](node, st, c);

      { return function (type) { return type === test; } }

      { return function () { return true; } }

  var Found = function Found(node, state) { this.node = node; this.state = state; };

  // A full walk triggers the callback on each node

  function full(node, callback, baseVisitor, state, override) {

    if (!baseVisitor) { baseVisitor = base; }

  // An fullAncestor walk is like an ancestor walk, but triggers

  function fullAncestor(node, callback, baseVisitor, state) {

        callback(node, st || ancestors, ancestors, type);

  // Find a node with a given start, end, and type (all are optional,

  // null can be used as wildcard). Returns a {node, state} object, or

  // undefined when it doesn't find a matching node.

  function findNodeAt(node, start, end, test, baseVisitor, state) {

        var type = override || node.type;

        if ((start == null || node.start <= start) &&

            (end == null || node.end >= end))

          { baseVisitor[type](node, st, c); }

        if ((start == null || node.start === start) &&

            (end == null || node.end === end) &&

      if (e instanceof Found) { return e }

  // Find the innermost node of a given type that contains the given

  // position. Interface similar to findNodeAt.

  function findNodeAround(node, pos, test, baseVisitor, state) {

        if (node.start > pos || node.end < pos) { return }

        if (test(type, node)) { throw new Found(node, st) }

  // Find the outermost matching node after a given position.

  "description": "ECMAScript (ESTree) AST walker",

  "homepage": "https://github.com/acornjs/acorn",

      "web": "https://marijnhaverbeke.nl"

    "url": "https://github.com/acornjs/acorn.git"

    "prepare": "cd ..; npm run build:walk"

		@@ -0,1 +1,9 @@
		## 8.3.1 (2023-12-06)

		### Bug fixes

		Add `Function` and `Class` to the `AggregateType` type, so that they can be used in walkers without raising a type error.

		Visitor functions are now called in such a way that their `this` refers to the object they are part of.

		## 8.3.0 (2023-10-26)
		@@ -2,0 +10,0 @@

		@@ -19,2 +19,4 @@ import * as acorn from "acorn"
		Statement: acorn.Statement,
		Function: acorn.Function,
		Class: acorn.Class,
		Pattern: acorn.Pattern,
		@@ -21,0 +23,0 @@ ForInit: acorn.VariableDeclaration \| acorn.Expression

		@@ -19,3 +19,3 @@ {
		},
		"version": "8.3.0",
		"version": "8.3.1",
		"engines": {
		@@ -22,0 +22,0 @@ "node": ">=0.4.0"

		@@ -7,3 +7,3 @@ (function (global, factory) {

		// AST walker module for Mozilla Parser API compatible trees
		// AST walker module for ESTree compatible trees

		@@ -18,3 +18,3 @@ // A simple walk is one where you simply specify callbacks to be
		//
		// to do something with all expressions. All Parser API node types
		// to do something with all expressions. All ESTree node types
		// can be used to identify node types, as well as Expression and
		@@ -30,5 +30,5 @@ // Statement, which denote categories of nodes.
		; }(function c(node, st, override) {
		var type = override \|\| node.type, found = visitors[type];
		var type = override \|\| node.type;
		baseVisitor[type](node, st, c);
		if (found) { found(node, st); }
		if (visitors[type]) { visitors[type](node, st); }
		})(node, state, override);
		@@ -44,7 +44,7 @@ }
		; }(function c(node, st, override) {
		var type = override \|\| node.type, found = visitors[type];
		var type = override \|\| node.type;
		var isNew = node !== ancestors[ancestors.length - 1];
		if (isNew) { ancestors.push(node); }
		baseVisitor[type](node, st, c);
		if (found) { found(node, st \|\| ancestors, ancestors); }
		if (visitors[type]) { visitors[type](node, st \|\| ancestors, ancestors); }
		if (isNew) { ancestors.pop(); }
		@@ -51,0 +51,0 @@ })(node, state, override);

Improved metrics