{"version":3,"sources":["jsdelivr-header.js","/npm/acorn-walk@7.1.1/src/index.js"],"names":[],"mappings":"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","file":"/npm/acorn-walk@7.1.1/dist/walk.js","sourceRoot":"","sourcesContent":["/**\n * Minified by jsDelivr using Terser v5.39.0.\n * Original file: /npm/acorn-walk@7.1.1/dist/walk.js\n *\n * Do NOT use SRI with dynamically generated files! More information: https://www.jsdelivr.com/using-sri-with-dynamic-files\n */\n","// AST walker module for Mozilla Parser API compatible trees\n\n// A simple walk is one where you simply specify callbacks to be\n// called on specific nodes. The last two arguments are optional. A\n// simple use would be\n//\n//     walk.simple(myTree, {\n//         Expression: function(node) { ... }\n//     });\n//\n// to do something with all expressions. All Parser API node types\n// can be used to identify node types, as well as Expression and\n// Statement, which denote categories of nodes.\n//\n// The base argument can be used to pass a custom (recursive)\n// walker, and state can be used to give this walked an initial\n// state.\n\nexport function simple(node, visitors, baseVisitor, state, override) {\n  if (!baseVisitor) baseVisitor = base\n  ;(function c(node, st, override) {\n    let type = override || node.type, found = visitors[type]\n    baseVisitor[type](node, st, c)\n    if (found) found(node, st)\n  })(node, state, override)\n}\n\n// An ancestor walk keeps an array of ancestor nodes (including the\n// current node) and passes them to the callback as third parameter\n// (and also as state parameter when no other state is present).\nexport function ancestor(node, visitors, baseVisitor, state) {\n  let ancestors = []\n  if (!baseVisitor) baseVisitor = base\n  ;(function c(node, st, override) {\n    let type = override || node.type, found = visitors[type]\n    let isNew = node !== ancestors[ancestors.length - 1]\n    if (isNew) ancestors.push(node)\n    baseVisitor[type](node, st, c)\n    if (found) found(node, st || ancestors, ancestors)\n    if (isNew) ancestors.pop()\n  })(node, state)\n}\n\n// A recursive walk is one where your functions override the default\n// walkers. They can modify and replace the state parameter that's\n// threaded through the walk, and can opt how and whether to walk\n// their child nodes (by calling their third argument on these\n// nodes).\nexport function recursive(node, state, funcs, baseVisitor, override) {\n  let visitor = funcs ? make(funcs, baseVisitor || undefined) : baseVisitor\n  ;(function c(node, st, override) {\n    visitor[override || node.type](node, st, c)\n  })(node, state, override)\n}\n\nfunction makeTest(test) {\n  if (typeof test === \"string\")\n    return type => type === test\n  else if (!test)\n    return () => true\n  else\n    return test\n}\n\nclass Found {\n  constructor(node, state) { this.node = node; this.state = state }\n}\n\n// A full walk triggers the callback on each node\nexport function full(node, callback, baseVisitor, state, override) {\n  if (!baseVisitor) baseVisitor = base\n  ;(function c(node, st, override) {\n    let type = override || node.type\n    baseVisitor[type](node, st, c)\n    if (!override) callback(node, st, type)\n  })(node, state, override)\n}\n\n// An fullAncestor walk is like an ancestor walk, but triggers\n// the callback on each node\nexport function fullAncestor(node, callback, baseVisitor, state) {\n  if (!baseVisitor) baseVisitor = base\n  let ancestors = []\n  ;(function c(node, st, override) {\n    let type = override || node.type\n    let isNew = node !== ancestors[ancestors.length - 1]\n    if (isNew) ancestors.push(node)\n    baseVisitor[type](node, st, c)\n    if (!override) callback(node, st || ancestors, ancestors, type)\n    if (isNew) ancestors.pop()\n  })(node, state)\n}\n\n// Find a node with a given start, end, and type (all are optional,\n// null can be used as wildcard). Returns a {node, state} object, or\n// undefined when it doesn't find a matching node.\nexport function findNodeAt(node, start, end, test, baseVisitor, state) {\n  if (!baseVisitor) baseVisitor = base\n  test = makeTest(test)\n  try {\n    (function c(node, st, override) {\n      let type = override || node.type\n      if ((start == null || node.start <= start) &&\n          (end == null || node.end >= end))\n        baseVisitor[type](node, st, c)\n      if ((start == null || node.start === start) &&\n          (end == null || node.end === end) &&\n          test(type, node))\n        throw new Found(node, st)\n    })(node, state)\n  } catch (e) {\n    if (e instanceof Found) return e\n    throw e\n  }\n}\n\n// Find the innermost node of a given type that contains the given\n// position. Interface similar to findNodeAt.\nexport function findNodeAround(node, pos, test, baseVisitor, state) {\n  test = makeTest(test)\n  if (!baseVisitor) baseVisitor = base\n  try {\n    (function c(node, st, override) {\n      let type = override || node.type\n      if (node.start > pos || node.end < pos) return\n      baseVisitor[type](node, st, c)\n      if (test(type, node)) throw new Found(node, st)\n    })(node, state)\n  } catch (e) {\n    if (e instanceof Found) return e\n    throw e\n  }\n}\n\n// Find the outermost matching node after a given position.\nexport function findNodeAfter(node, pos, test, baseVisitor, state) {\n  test = makeTest(test)\n  if (!baseVisitor) baseVisitor = base\n  try {\n    (function c(node, st, override) {\n      if (node.end < pos) return\n      let type = override || node.type\n      if (node.start >= pos && test(type, node)) throw new Found(node, st)\n      baseVisitor[type](node, st, c)\n    })(node, state)\n  } catch (e) {\n    if (e instanceof Found) return e\n    throw e\n  }\n}\n\n// Find the outermost matching node before a given position.\nexport function findNodeBefore(node, pos, test, baseVisitor, state) {\n  test = makeTest(test)\n  if (!baseVisitor) baseVisitor = base\n  let max\n  ;(function c(node, st, override) {\n    if (node.start > pos) return\n    let type = override || node.type\n    if (node.end <= pos && (!max || max.node.end < node.end) && test(type, node))\n      max = new Found(node, st)\n    baseVisitor[type](node, st, c)\n  })(node, state)\n  return max\n}\n\n// Fallback to an Object.create polyfill for older environments.\nconst create = Object.create || function(proto) {\n  function Ctor() {}\n  Ctor.prototype = proto\n  return new Ctor\n}\n\n// Used to create a custom walker. Will fill in all missing node\n// type properties with the defaults.\nexport function make(funcs, baseVisitor) {\n  let visitor = create(baseVisitor || base)\n  for (let type in funcs) visitor[type] = funcs[type]\n  return visitor\n}\n\nfunction skipThrough(node, st, c) { c(node, st) }\nfunction ignore(_node, _st, _c) {}\n\n// Node walkers.\n\nexport const base = {}\n\nbase.Program = base.BlockStatement = (node, st, c) => {\n  for (let stmt of node.body)\n    c(stmt, st, \"Statement\")\n}\nbase.Statement = skipThrough\nbase.EmptyStatement = ignore\nbase.ExpressionStatement = base.ParenthesizedExpression =\n  (node, st, c) => c(node.expression, st, \"Expression\")\nbase.IfStatement = (node, st, c) => {\n  c(node.test, st, \"Expression\")\n  c(node.consequent, st, \"Statement\")\n  if (node.alternate) c(node.alternate, st, \"Statement\")\n}\nbase.LabeledStatement = (node, st, c) => c(node.body, st, \"Statement\")\nbase.BreakStatement = base.ContinueStatement = ignore\nbase.WithStatement = (node, st, c) => {\n  c(node.object, st, \"Expression\")\n  c(node.body, st, \"Statement\")\n}\nbase.SwitchStatement = (node, st, c) => {\n  c(node.discriminant, st, \"Expression\")\n  for (let cs of node.cases) {\n    if (cs.test) c(cs.test, st, \"Expression\")\n    for (let cons of cs.consequent)\n      c(cons, st, \"Statement\")\n  }\n}\nbase.SwitchCase = (node, st, c) => {\n  if (node.test) c(node.test, st, \"Expression\")\n  for (let cons of node.consequent)\n    c(cons, st, \"Statement\")\n}\nbase.ReturnStatement = base.YieldExpression = base.AwaitExpression = (node, st, c) => {\n  if (node.argument) c(node.argument, st, \"Expression\")\n}\nbase.ThrowStatement = base.SpreadElement =\n  (node, st, c) => c(node.argument, st, \"Expression\")\nbase.TryStatement = (node, st, c) => {\n  c(node.block, st, \"Statement\")\n  if (node.handler) c(node.handler, st)\n  if (node.finalizer) c(node.finalizer, st, \"Statement\")\n}\nbase.CatchClause = (node, st, c) => {\n  if (node.param) c(node.param, st, \"Pattern\")\n  c(node.body, st, \"Statement\")\n}\nbase.WhileStatement = base.DoWhileStatement = (node, st, c) => {\n  c(node.test, st, \"Expression\")\n  c(node.body, st, \"Statement\")\n}\nbase.ForStatement = (node, st, c) => {\n  if (node.init) c(node.init, st, \"ForInit\")\n  if (node.test) c(node.test, st, \"Expression\")\n  if (node.update) c(node.update, st, \"Expression\")\n  c(node.body, st, \"Statement\")\n}\nbase.ForInStatement = base.ForOfStatement = (node, st, c) => {\n  c(node.left, st, \"ForInit\")\n  c(node.right, st, \"Expression\")\n  c(node.body, st, \"Statement\")\n}\nbase.ForInit = (node, st, c) => {\n  if (node.type === \"VariableDeclaration\") c(node, st)\n  else c(node, st, \"Expression\")\n}\nbase.DebuggerStatement = ignore\n\nbase.FunctionDeclaration = (node, st, c) => c(node, st, \"Function\")\nbase.VariableDeclaration = (node, st, c) => {\n  for (let decl of node.declarations)\n    c(decl, st)\n}\nbase.VariableDeclarator = (node, st, c) => {\n  c(node.id, st, \"Pattern\")\n  if (node.init) c(node.init, st, \"Expression\")\n}\n\nbase.Function = (node, st, c) => {\n  if (node.id) c(node.id, st, \"Pattern\")\n  for (let param of node.params)\n    c(param, st, \"Pattern\")\n  c(node.body, st, node.expression ? \"Expression\" : \"Statement\")\n}\n\nbase.Pattern = (node, st, c) => {\n  if (node.type === \"Identifier\")\n    c(node, st, \"VariablePattern\")\n  else if (node.type === \"MemberExpression\")\n    c(node, st, \"MemberPattern\")\n  else\n    c(node, st)\n}\nbase.VariablePattern = ignore\nbase.MemberPattern = skipThrough\nbase.RestElement = (node, st, c) => c(node.argument, st, \"Pattern\")\nbase.ArrayPattern = (node, st, c) => {\n  for (let elt of node.elements) {\n    if (elt) c(elt, st, \"Pattern\")\n  }\n}\nbase.ObjectPattern = (node, st, c) => {\n  for (let prop of node.properties) {\n    if (prop.type === \"Property\") {\n      if (prop.computed) c(prop.key, st, \"Expression\")\n      c(prop.value, st, \"Pattern\")\n    } else if (prop.type === \"RestElement\") {\n      c(prop.argument, st, \"Pattern\")\n    }\n  }\n}\n\nbase.Expression = skipThrough\nbase.ThisExpression = base.Super = base.MetaProperty = ignore\nbase.ArrayExpression = (node, st, c) => {\n  for (let elt of node.elements) {\n    if (elt) c(elt, st, \"Expression\")\n  }\n}\nbase.ObjectExpression = (node, st, c) => {\n  for (let prop of node.properties)\n    c(prop, st)\n}\nbase.FunctionExpression = base.ArrowFunctionExpression = base.FunctionDeclaration\nbase.SequenceExpression = (node, st, c) => {\n  for (let expr of node.expressions)\n    c(expr, st, \"Expression\")\n}\nbase.TemplateLiteral = (node, st, c) => {\n  for (let quasi of node.quasis)\n    c(quasi, st)\n\n  for (let expr of node.expressions)\n    c(expr, st, \"Expression\")\n}\nbase.TemplateElement = ignore\nbase.UnaryExpression = base.UpdateExpression = (node, st, c) => {\n  c(node.argument, st, \"Expression\")\n}\nbase.BinaryExpression = base.LogicalExpression = (node, st, c) => {\n  c(node.left, st, \"Expression\")\n  c(node.right, st, \"Expression\")\n}\nbase.AssignmentExpression = base.AssignmentPattern = (node, st, c) => {\n  c(node.left, st, \"Pattern\")\n  c(node.right, st, \"Expression\")\n}\nbase.ConditionalExpression = (node, st, c) => {\n  c(node.test, st, \"Expression\")\n  c(node.consequent, st, \"Expression\")\n  c(node.alternate, st, \"Expression\")\n}\nbase.NewExpression = base.CallExpression = (node, st, c) => {\n  c(node.callee, st, \"Expression\")\n  if (node.arguments)\n    for (let arg of node.arguments)\n      c(arg, st, \"Expression\")\n}\nbase.MemberExpression = (node, st, c) => {\n  c(node.object, st, \"Expression\")\n  if (node.computed) c(node.property, st, \"Expression\")\n}\nbase.ExportNamedDeclaration = base.ExportDefaultDeclaration = (node, st, c) => {\n  if (node.declaration)\n    c(node.declaration, st, node.type === \"ExportNamedDeclaration\" || node.declaration.id ? \"Statement\" : \"Expression\")\n  if (node.source) c(node.source, st, \"Expression\")\n}\nbase.ExportAllDeclaration = (node, st, c) => {\n  c(node.source, st, \"Expression\")\n}\nbase.ImportDeclaration = (node, st, c) => {\n  for (let spec of node.specifiers)\n    c(spec, st)\n  c(node.source, st, \"Expression\")\n}\nbase.ImportSpecifier = base.ImportDefaultSpecifier = base.ImportNamespaceSpecifier = base.Identifier = base.Literal = ignore\n\nbase.TaggedTemplateExpression = (node, st, c) => {\n  c(node.tag, st, \"Expression\")\n  c(node.quasi, st, \"Expression\")\n}\nbase.ClassDeclaration = base.ClassExpression = (node, st, c) => c(node, st, \"Class\")\nbase.Class = (node, st, c) => {\n  if (node.id) c(node.id, st, \"Pattern\")\n  if (node.superClass) c(node.superClass, st, \"Expression\")\n  c(node.body, st)\n}\nbase.ClassBody = (node, st, c) => {\n  for (let elt of node.body)\n    c(elt, st)\n}\nbase.MethodDefinition = base.Property = (node, st, c) => {\n  if (node.computed) c(node.key, st, \"Expression\")\n  c(node.value, st, \"Expression\")\n}\n"]}