@knighted/module 1.0.0-alpha.9 → 1.0.0-beta.0

package/dist/helpers/identifier.js

@@ -0,0 +1,127 @@
+import { analyze } from 'periscopic';
+
+/**
+ * Focus exclusively on IdentifierName type as it has the name property,
+ * which is what the identifer utilities are interested in.
+ *
+ * Explicitly ignore the TSThisParameter type as it is not a valid identifier name.
+ */
+const isIdentifierName = node => {
+  return node.type === 'Identifier' && typeof node.name === 'string' && node.name !== 'this';
+};
+const scopeCache = new WeakMap();
+const getScopeContext = program => {
+  const cached = scopeCache.get(program);
+  if (cached) {
+    return cached;
+  }
+  const {
+    scope
+  } = analyze(program);
+  const context = {
+    scope
+  };
+  scopeCache.set(program, context);
+  return context;
+};
+
+/**
+ * All methods receive the full set of ancestors, which
+ * specifically includes the node itself as the last element.
+ * The second to last element is the parent node, and so on.
+ * The first element is the root node.
+ */
+const identifier = {
+  isNamed: node => {
+    return isIdentifierName(node);
+  },
+  isMetaProperty(ancestors) {
+    const parent = ancestors[ancestors.length - 2];
+    return parent.type === 'MetaProperty' || parent.type === 'MemberExpression' && parent.object.type === 'MetaProperty';
+  },
+  isModuleScope(ancestors, includeImports = false) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    const program = ancestors[0];
+    if (!identifier.isNamed(node) || identifier.isMetaProperty(ancestors) || parent.type === 'LabeledStatement' || parent.type === 'BreakStatement' || parent.type === 'ContinueStatement') {
+      return false;
+    }
+    if (parent.type === 'ImportSpecifier' || parent.type === 'ImportDefaultSpecifier' || parent.type === 'ImportNamespaceSpecifier') {
+      return includeImports && parent.local.name === node.name;
+    }
+    if (parent.type === 'Property' && parent.key === node && !parent.computed) {
+      return false;
+    }
+    if (parent.type === 'MemberExpression' && parent.property === node && !parent.computed) {
+      return false;
+    }
+    const {
+      scope: rootScope
+    } = getScopeContext(program);
+    const owner = rootScope.find_owner(node.name);
+    if (!owner) {
+      return node.name === 'exports';
+    }
+    return owner === rootScope;
+  },
+  isMemberExpressionRoot(ancestors) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    const grandParent = ancestors[ancestors.length - 3];
+    return parent.type === 'MemberExpression' && parent.object === node && grandParent.type !== 'MemberExpression';
+  },
+  isDeclaration(ancestors) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    return (parent.type === 'VariableDeclarator' || parent.type === 'FunctionDeclaration' || parent.type === 'ClassDeclaration') && parent.id === node;
+  },
+  isClassOrFuncDeclarationId(ancestors) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    return (parent.type === 'ClassDeclaration' || parent.type === 'FunctionDeclaration') && parent.id === node && ancestors.length <= 3;
+  },
+  isVarDeclarationInGlobalScope(ancestors) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    const grandParent = ancestors[ancestors.length - 3];
+    const varBoundScopes = ['ClassDeclaration', 'ClassExpression', 'FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression'];
+    return parent.type === 'VariableDeclarator' && parent.id === node && grandParent.type === 'VariableDeclaration' && grandParent.kind === 'var' && ancestors.every(ancestor => {
+      return !varBoundScopes.includes(ancestor.type);
+    });
+  },
+  isIife(ancestors) {
+    const parent = ancestors[ancestors.length - 2];
+    return parent.type === 'FunctionExpression' && ancestors.some(ancestor => ancestor.type === 'ParenthesizedExpression');
+  },
+  isFunctionExpressionId(ancestors) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    return parent.type === 'FunctionExpression' && parent.id === node;
+  },
+  isExportSpecifierAlias(ancestors) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    return parent.type === 'ExportSpecifier' && parent.exported === node;
+  },
+  isClassPropertyKey(ancestors) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    return parent.type === 'PropertyDefinition' && parent.key === node;
+  },
+  isMethodDefinitionKey(ancestors) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    return parent.type === 'MethodDefinition' && parent.key === node;
+  },
+  isMemberKey(ancestors) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    return parent.type === 'MemberExpression' && parent.property === node;
+  },
+  isPropertyKey(ancestors) {
+    const node = ancestors[ancestors.length - 1];
+    const parent = ancestors[ancestors.length - 2];
+    return parent.type === 'Property' && parent.key === node;
+  }
+};
+export { identifier, isIdentifierName };

package/dist/helpers/scope.d.ts

@@ -0,0 +1,6 @@
+import type { Node } from 'oxc-parser';
+declare const scopes: string[];
+declare const scope: {
+    isScope(node: Node): boolean;
+};
+export { scopes, scope };

package/dist/helpers/scope.js

@@ -0,0 +1,7 @@
+const scopes = ['BlockStatement', 'FunctionDeclaration', 'FunctionExpression', 'ArrowFunctionExpression', 'ClassDeclaration', 'ClassExpression', 'ClassBody', 'StaticBlock'];
+const scope = {
+  isScope(node) {
+    return scopes.includes(node.type);
+  }
+};
+export { scopes, scope };

package/dist/identifier.d.ts

@@ -1,5 +1,31 @@
-import MagicString from 'magic-string';
-import type { NodePath } from '@babel/traverse';
-import type { Identifier } from '@babel/types';
-import type { FormatterOptions } from '../types.js';
-export declare const identifier: (nodePath: NodePath<Identifier>, src: MagicString, options: FormatterOptions) => void;
+import type { Node, IdentifierName } from 'oxc-parser';
+/**
+ * Focus exclusively on IdentifierName type as it has the name property,
+ * which is what the identifer utilities are interested in.
+ *
+ * Explicitly ignore the TSThisParameter type as it is not a valid identifier name.
+ */
+declare const isIdentifierName: (node: Node) => node is IdentifierName;
+/**
+ * All methods receive the full set of ancestors, which
+ * specifically includes the node itself as the last element.
+ * The second to last element is the parent node, and so on.
+ * The first element is the root node.
+ */
+declare const identifier: {
+    isNamed: (node: Node) => node is IdentifierName;
+    isMetaProperty(ancestors: Node[]): boolean;
+    isModuleScope(ancestors: Node[], includeImports?: boolean): boolean;
+    isMemberExpressionRoot(ancestors: Node[]): boolean;
+    isDeclaration(ancestors: Node[]): boolean;
+    isClassOrFuncDeclarationId(ancestors: Node[]): boolean;
+    isVarDeclarationInGlobalScope(ancestors: Node[]): boolean;
+    isIife(ancestors: Node[]): boolean;
+    isFunctionExpressionId(ancestors: Node[]): boolean;
+    isExportSpecifierAlias(ancestors: Node[]): boolean;
+    isClassPropertyKey(ancestors: Node[]): boolean;
+    isMethodDefinitionKey(ancestors: Node[]): boolean;
+    isMemberKey(ancestors: Node[]): boolean;
+    isPropertyKey(ancestors: Node[]): boolean;
+};
+export { identifier, isIdentifierName };

package/dist/memberExpression.d.ts

@@ -1,5 +1,4 @@
 import MagicString from 'magic-string';
-import type { NodePath } from '@babel/traverse';
-import type { MemberExpression } from '@babel/types';
+import type { MemberExpression, Node } from 'oxc-parser';
 import type { FormatterOptions } from '../types.js';
-export declare const memberExpression: (nodePath: NodePath<MemberExpression>, src: MagicString, options: FormatterOptions) => void;
+export declare const memberExpression: (node: MemberExpression, parent: Node | null, src: MagicString, options: FormatterOptions) => void;

package/dist/metaProperty.d.ts

@@ -1,5 +1,4 @@
 import MagicString from 'magic-string';
-import type { NodePath } from '@babel/traverse';
-import type { MetaProperty } from '@babel/types';
+import type { Node, MetaProperty } from 'oxc-parser';
 import type { FormatterOptions } from '../types.js';
-export declare const metaProperty: (nodePath: NodePath<MetaProperty>, src: MagicString, options: FormatterOptions) => void;
+export declare const metaProperty: (node: MetaProperty, parent: Node | null, src: MagicString, options: FormatterOptions) => void;

package/dist/module.js

@@ -1,28 +1,22 @@
-import { resolve, extname } from 'node:path';
+import { resolve } from 'node:path';
 import { readFile, writeFile } from 'node:fs/promises';
 import { specifier } from '@knighted/specifier';
 import { parse } from './parse.js';
 import { format } from './format.js';
+import { getLangFromExt } from './utils.js';
 const defaultOptions = {
-  type: 'commonjs',
+  target: 'commonjs',
+  sourceType: 'auto',
+  transformSyntax: true,
+  liveBindings: 'strict',
+  rewriteSpecifier: undefined,
+  dirFilename: 'inject',
+  importMeta: 'shim',
+  requireSource: 'builtin',
+  cjsDefault: 'auto',
+  topLevelAwait: 'error',
   out: undefined,
-  modules: false,
-  specifier: undefined
-};
-const getLangFromExt = filename => {
-  const ext = extname(filename);
-  if (/\.js$/.test(ext)) {
-    return 'js';
-  }
-  if (/\.ts$/.test(ext)) {
-    return 'ts';
-  }
-  if (ext === '.tsx') {
-    return 'tsx';
-  }
-  if (ext === '.jsx') {
-    return 'jsx';
-  }
+  inPlace: false
 };
 const transform = async (filename, options = defaultOptions) => {
   const opts = {
@@ -31,24 +25,29 @@ const transform = async (filename, options = defaultOptions) => {
   };
   const file = resolve(filename);
   const code = (await readFile(file)).toString();
-  const ast = parse(code);
-  let source = format(code, ast, opts).toString();
-  if (options.specifier) {
+  const ast = parse(filename, code);
+  let source = await format(code, ast, opts);
+  if (opts.rewriteSpecifier) {
     const code = await specifier.updateSrc(source, getLangFromExt(filename), ({
       value
     }) => {
+      if (typeof opts.rewriteSpecifier === 'function') {
+        return opts.rewriteSpecifier(value) ?? undefined;
+      }
+
       // Collapse any BinaryExpression or NewExpression to test for a relative specifier
       const collapsed = value.replace(/['"`+)\s]|new String\(/g, '');
       const relative = /^(?:\.|\.\.)\//;
       if (relative.test(collapsed)) {
         // $2 is for any closing quotation/parens around BE or NE
-        return value.replace(/(.+)\.(?:m|c)?(?:j|t)s([)'"`]*)?$/, `$1${options.specifier}$2`);
+        return value.replace(/(.+)\.(?:m|c)?(?:j|t)s([)'"]*)?$/, `$1${opts.rewriteSpecifier}$2`);
       }
     });
     source = code;
   }
-  if (opts.out) {
-    await writeFile(resolve(opts.out), source);
+  const outputPath = opts.inPlace ? file : opts.out ? resolve(opts.out) : undefined;
+  if (outputPath) {
+    await writeFile(outputPath, source);
   }
   return source;
 };

package/dist/parse.d.ts

@@ -1,2 +1,2 @@
-declare const parse: (source: string, dts?: boolean) => import("@babel/parser").ParseResult<import("@babel/types").File>;
+declare const parse: (filename: string, code: string) => import("oxc-parser").ParseResult;
 export { parse };

package/dist/parse.js

@@ -1,16 +1,5 @@
-import { parse as babelParse } from '@babel/parser';
-const parse = (source, dts = false) => {
-  const ast = babelParse(source, {
-    sourceType: 'module',
-    allowAwaitOutsideFunction: true,
-    allowReturnOutsideFunction: true,
-    allowImportExportEverywhere: true,
-    plugins: ['jsx', ['importAttributes', {
-      deprecatedAssertSyntax: true
-    }], ['typescript', {
-      dts
-    }]]
-  });
-  return ast;
+import { parseSync } from 'oxc-parser';
+const parse = (filename, code) => {
+  return parseSync(filename, code);
 };
 export { parse };

package/dist/scope.d.ts

@@ -0,0 +1,6 @@
+import type { Node } from 'oxc-parser';
+declare const scopes: string[];
+declare const scope: {
+    isScope(node: Node): boolean;
+};
+export { scopes, scope };

package/dist/types.d.ts

@@ -1,7 +1,35 @@
+import type { Node, Span, IdentifierName, IdentifierReference, BindingIdentifier, LabelIdentifier, TSIndexSignatureName } from 'oxc-parser';
+export type RewriteSpecifier = '.js' | '.mjs' | '.cjs' | '.ts' | '.mts' | '.cts' | ((value: string) => string | null | undefined);
 export type ModuleOptions = {
-    type?: 'module' | 'commonjs';
-    modules?: boolean;
-    specifier?: '.js' | '.mjs' | '.cjs' | '.ts' | '.mts' | '.cts';
+    target: 'module' | 'commonjs';
+    sourceType?: 'auto' | 'module' | 'commonjs';
+    transformSyntax?: boolean;
+    liveBindings?: 'strict' | 'loose' | 'off';
+    rewriteSpecifier?: RewriteSpecifier;
+    dirFilename?: 'inject' | 'preserve' | 'error';
+    importMeta?: 'preserve' | 'shim' | 'error';
+    requireSource?: 'builtin' | 'create-require';
+    cjsDefault?: 'module-exports' | 'auto' | 'none';
+    topLevelAwait?: 'error' | 'wrap' | 'preserve';
     out?: string;
+    inPlace?: boolean;
 };
-export type FormatterOptions = Omit<ModuleOptions, 'out'> & Required<Pick<ModuleOptions, 'type'>>;
+export type SpannedNode = Node & Span;
+export type ExportsMeta = {
+    hasExportsBeenReassigned: boolean;
+    hasDefaultExportBeenReassigned: boolean;
+    hasDefaultExportBeenAssigned: boolean;
+    defaultExportValue: unknown;
+};
+export type IdentMeta = {
+    declare: SpannedNode[];
+    read: SpannedNode[];
+};
+export type Scope = {
+    type: string;
+    name: string;
+    node: Node;
+    idents: Set<string>;
+};
+export type FormatterOptions = Omit<ModuleOptions, 'out' | 'inPlace'>;
+export type Identifier = IdentifierName | IdentifierReference | BindingIdentifier | LabelIdentifier | TSIndexSignatureName;

package/dist/utils.d.ts

@@ -0,0 +1,25 @@
+import type { Node } from 'oxc-parser';
+import type { Specifier } from '@knighted/specifier';
+import type { IdentMeta, Scope } from './types.js';
+type UpdateSrcLang = Parameters<Specifier['updateSrc']>[1];
+declare const getLangFromExt: (filename: string) => UpdateSrcLang;
+declare const isValidUrl: (url: string) => boolean;
+declare const exportsRename = "__exports";
+declare const requireMainRgx: RegExp;
+declare const collectScopeIdentifiers: (node: Node, scopes: Scope[]) => void;
+/**
+ * Collects all module scope identifiers in the AST.
+ *
+ * Ignores identifiers that are in functions or classes.
+ * Ignores new scopes for StaticBlock nodes (can only reference static class members).
+ *
+ * Special case handling for these which create their own scopes,
+ * but are also valid module scope identifiers:
+ * - ClassDeclaration
+ * - FunctionDeclaration
+ *
+ * Special case handling for var inside BlockStatement
+ * which are also valid module scope identifiers.
+ */
+declare const collectModuleIdentifiers: (ast: Node, hoisting?: boolean) => Promise<Map<string, IdentMeta>>;
+export { getLangFromExt, isValidUrl, collectScopeIdentifiers, collectModuleIdentifiers, exportsRename, requireMainRgx, };

package/dist/utils.js

@@ -0,0 +1,209 @@
+import { extname } from 'node:path';
+import { ancestorWalk } from './walk.js';
+import { scopes as scopeNodes } from './helpers/scope.js';
+import { identifier } from './helpers/identifier.js';
+const getLangFromExt = filename => {
+  const ext = extname(filename);
+  if (ext.endsWith('.js')) {
+    return 'js';
+  }
+  if (ext.endsWith('.ts')) {
+    return 'ts';
+  }
+  if (ext === '.tsx') {
+    return 'tsx';
+  }
+  if (ext === '.jsx') {
+    return 'jsx';
+  }
+};
+const isValidUrl = url => {
+  try {
+    new URL(url);
+    return true;
+  } catch {
+    return false;
+  }
+};
+const exportsRename = '__exports';
+const requireMainRgx = /(require\.main\s*===\s*module|module\s*===\s*require\.main)/g;
+const collectScopeIdentifiers = (node, scopes) => {
+  const {
+    type
+  } = node;
+  switch (type) {
+    case 'BlockStatement':
+    case 'ClassBody':
+      scopes.push({
+        node,
+        type: 'Block',
+        name: type,
+        idents: new Set()
+      });
+      break;
+    case 'FunctionDeclaration':
+    case 'FunctionExpression':
+    case 'ArrowFunctionExpression':
+      {
+        const name = node.id ? node.id.name : 'anonymous';
+        const scope = {
+          node,
+          name,
+          type: 'Function',
+          idents: new Set()
+        };
+        node.params.map(param => {
+          if (param.type === 'TSParameterProperty') {
+            return param.parameter;
+          }
+          if (param.type === 'RestElement') {
+            return param.argument;
+          }
+          if (param.type === 'AssignmentPattern') {
+            return param.left;
+          }
+          return param;
+        }).filter(identifier.isNamed).forEach(param => {
+          scope.idents.add(param.name);
+        });
+
+        /**
+         * If a FunctionExpression has an id, it is a named function expression.
+         * The function expression name shadows the module scope identifier, so
+         * we don't want to count reads of module identifers that have the same name.
+         * They also do not cause a SyntaxError if the function expression name is
+         * the same as a module scope identifier.
+         *
+         * TODO: Is this necessary for FunctionDeclaration?
+         */
+        if (node.type === 'FunctionExpression' && node.id) {
+          scope.idents.add(node.id.name);
+        }
+
+        // First add the function to any previous scopes
+        if (scopes.length > 0) {
+          scopes[scopes.length - 1].idents.add(name);
+        }
+
+        // Then add the function scope to the scopes stack
+        scopes.push(scope);
+      }
+      break;
+    case 'ClassDeclaration':
+      {
+        const className = node.id ? node.id.name : 'anonymous';
+
+        // First add the class to any previous scopes
+        if (scopes.length > 0) {
+          scopes[scopes.length - 1].idents.add(className);
+        }
+
+        // Then add the class to the scopes stack
+        scopes.push({
+          node,
+          name: className,
+          type: 'Class',
+          idents: new Set()
+        });
+      }
+      break;
+    case 'ClassExpression':
+      {}
+      break;
+    case 'VariableDeclaration':
+      if (scopes.length > 0) {
+        const scope = scopes[scopes.length - 1];
+        node.declarations.forEach(decl => {
+          if (decl.type === 'VariableDeclarator' && decl.id.type === 'Identifier') {
+            scope.idents.add(decl.id.name);
+          }
+        });
+      }
+      break;
+  }
+};
+
+/**
+ * Collects all module scope identifiers in the AST.
+ *
+ * Ignores identifiers that are in functions or classes.
+ * Ignores new scopes for StaticBlock nodes (can only reference static class members).
+ *
+ * Special case handling for these which create their own scopes,
+ * but are also valid module scope identifiers:
+ * - ClassDeclaration
+ * - FunctionDeclaration
+ *
+ * Special case handling for var inside BlockStatement
+ * which are also valid module scope identifiers.
+ */
+const collectModuleIdentifiers = async (ast, hoisting = true) => {
+  const identifiers = new Map();
+  const globalReads = new Map();
+  const scopes = [];
+  await ancestorWalk(ast, {
+    enter(node, ancestors) {
+      const {
+        type
+      } = node;
+      collectScopeIdentifiers(node, scopes);
+
+      // Add module scope identifiers to the registry map
+
+      if (type === 'Identifier') {
+        const {
+          name
+        } = node;
+        const meta = identifiers.get(name) ?? {
+          declare: [],
+          read: []
+        };
+        const isDeclaration = identifier.isDeclaration(ancestors);
+        const inScope = scopes.some(scope => scope.idents.has(name) || scope.name === name);
+        if (hoisting && !identifier.isDeclaration(ancestors) && !identifier.isFunctionExpressionId(ancestors) && !identifier.isExportSpecifierAlias(ancestors) && !identifier.isClassPropertyKey(ancestors) && !identifier.isMethodDefinitionKey(ancestors) && !identifier.isMemberKey(ancestors) && !identifier.isPropertyKey(ancestors) && !identifier.isIife(ancestors) && !inScope) {
+          if (globalReads.has(name)) {
+            globalReads.get(name)?.push(node);
+          } else {
+            globalReads.set(name, [node]);
+          }
+        }
+        if (isDeclaration) {
+          const isModuleScope = identifier.isModuleScope(ancestors);
+          const isClassOrFuncDeclaration = identifier.isClassOrFuncDeclarationId(ancestors);
+          const isVarDeclarationInGlobalScope = identifier.isVarDeclarationInGlobalScope(ancestors);
+          if (isModuleScope || isClassOrFuncDeclaration || isVarDeclarationInGlobalScope) {
+            meta.declare.push(node);
+
+            // Check for hoisted reads
+            if (hoisting && globalReads.has(name)) {
+              const reads = globalReads.get(name);
+              if (reads) {
+                reads.forEach(read => {
+                  if (!meta.read.includes(read)) {
+                    meta.read.push(read);
+                  }
+                });
+              }
+            }
+            identifiers.set(name, meta);
+          }
+        } else {
+          if (identifiers.has(name) && !inScope && !identifier.isIife(ancestors) && !identifier.isFunctionExpressionId(ancestors) && !identifier.isExportSpecifierAlias(ancestors) && !identifier.isClassPropertyKey(ancestors) && !identifier.isMethodDefinitionKey(ancestors) && !identifier.isMemberKey(ancestors) && !identifier.isPropertyKey(ancestors)) {
+            // Closure is referencing module scope identifier
+            meta.read.push(node);
+          }
+        }
+      }
+    },
+    leave(node) {
+      const {
+        type
+      } = node;
+      if (scopeNodes.includes(type)) {
+        scopes.pop();
+      }
+    }
+  });
+  return identifiers;
+};
+export { getLangFromExt, isValidUrl, collectScopeIdentifiers, collectModuleIdentifiers, exportsRename, requireMainRgx };

package/dist/walk.d.ts

@@ -0,0 +1,20 @@
+import type { Node } from 'oxc-parser';
+/**
+ * Using visitorKeys instead of oxc Visitor to keep
+ * an ancestor-aware enter/leave API with this.skip()
+ * without per-node method boilerplate.
+ */
+type AncestorContext = {
+    skip: () => void;
+};
+type AncestorVisitor = {
+    enter?: (this: AncestorContext, node: Node, ancestors: Node[]) => void | Promise<void>;
+    leave?: (this: AncestorContext, node: Node, ancestors: Node[]) => void | Promise<void>;
+};
+type WalkVisitor = {
+    enter?: (this: AncestorContext, node: Node, parent: Node | null) => void | Promise<void>;
+    leave?: (this: AncestorContext, node: Node, parent: Node | null) => void | Promise<void>;
+};
+declare const ancestorWalk: (node: Node, visitors: AncestorVisitor) => Promise<void>;
+declare const walk: (node: Node, visitors: WalkVisitor) => Promise<void>;
+export { ancestorWalk, walk };

package/dist/walk.js

@@ -0,0 +1,69 @@
+import { visitorKeys } from 'oxc-parser';
+
+/**
+ * Using visitorKeys instead of oxc Visitor to keep
+ * an ancestor-aware enter/leave API with this.skip()
+ * without per-node method boilerplate.
+ */
+
+let skipDepth = -1;
+const isNodeLike = value => {
+  return Boolean(value && typeof value === 'object' && 'type' in value);
+};
+const traverse = async (node, visitors, ancestors, depth) => {
+  if (!node) return;
+  const keys = visitorKeys[node.type] ?? [];
+  const ctx = {
+    skip: () => {
+      skipDepth = depth;
+    }
+  };
+  ancestors.push(node);
+  if (visitors.enter) {
+    await visitors.enter.call(ctx, node, ancestors);
+  }
+  if (skipDepth === -1 || depth < skipDepth) {
+    const fields = node;
+    for (const key of keys) {
+      const child = fields[key];
+      if (Array.isArray(child)) {
+        for (const nested of child) {
+          if (isNodeLike(nested)) {
+            await traverse(nested, visitors, ancestors, depth + 1);
+          }
+        }
+      } else if (isNodeLike(child)) {
+        await traverse(child, visitors, ancestors, depth + 1);
+      }
+    }
+  }
+  if (visitors.leave) {
+    await visitors.leave.call(ctx, node, ancestors);
+  }
+  ancestors.pop();
+  if (skipDepth === depth) {
+    skipDepth = -1;
+  }
+};
+const ancestorWalk = async (node, visitors) => {
+  skipDepth = -1;
+  await traverse(node, visitors, [], 0);
+};
+const walk = async (node, visitors) => {
+  const wrap = {
+    enter(current, ancestors) {
+      const parent = ancestors[ancestors.length - 2] ?? null;
+      if (visitors.enter) {
+        return visitors.enter.call(this, current, parent);
+      }
+    },
+    leave(current, ancestors) {
+      const parent = ancestors[ancestors.length - 2] ?? null;
+      if (visitors.leave) {
+        return visitors.leave.call(this, current, parent);
+      }
+    }
+  };
+  await ancestorWalk(node, wrap);
+};
+export { ancestorWalk, walk };