How to use the @effectful/transducers.Tag.Identifier function in @effectful/transducers

export function idTok(pos, sym) {
  return tok(pos, Tag.Identifier, { sym });
}

if (i.enter && i.pos !== Tag.top) {
      switch (i.type) {
        case Tag.FunctionDeclaration:
          if (i.leave) {
            yield Kit.enter(i.pos, Tag.ExpressionStatement);
            yield Kit.tok(Tag.expression, Tag.Identifier, {
              node: { name: "$$$" }
            });
            yield Kit.leave(i.pos, Tag.ExpressionStatement);
            continue;
          }
          break;
        case Tag.FunctionExpression:
        case Tag.ArrowFunctionExpression:
          if (i.leave) {
            yield Kit.tok(i.pos, Tag.Identifier, { node: { name: "$$$" } });
            continue;
          }
      }
    }
    yield i;
  }
}

case Tag.TryStatement:
              if (!i.value.eff) {
                yield i;
                yield* _saveDecls(true);
                continue;
              }
              break;
            case Tag.CatchClause:
              if (sl.cur().pos === Tag.param) {
                if (pureTry) {
                  yield i;
                  for (const k of sl.one()) {
                    yield k;
                    if (
                      k.enter &&
                      k.type === Tag.Identifier &&
                      k.value.sym &&
                      k.value.decl
                    ) {
                      k.value.sym.interpr = null;
                    }
                  }
                } else {
                  const ids = [];
                  for (const j of sl.one()) {
                    if (j.enter && j.type === Tag.Identifier && j.value.decl) {
                      const { sym } = j.value;
                      if (!decls.has(sym)) decls.set(sym, { raw: null });
                      j.value.lhs = true;
                      j.value.rhs = false;
                      j.value.decl = false;
                    }

continue;
          case Tag.CallExpression:
            if (s.cur().type !== Tag.MemberExpression) break;
            const m = s.take();
            if (s.cur().type !== Tag.Super) {
              yield i;
              yield m;
              continue;
            }
            yield i;
            yield s.enter(Tag.callee, Tag.MemberExpression);
            yield s.enter(Tag.object, Tag.MemberExpression, m.value);
            yield* walk();
            yield* s.leave();
            s.close(m);
            yield s.tok(Tag.property, Tag.Identifier, {
              node: { name: "call" }
            });
            yield* s.leave();
            yield* s.till(i => i.pos === Tag.arguments);
            yield s.tok(Tag.push, Tag.Identifier, {
              sym: thisSym,
              lhs: false,
              rhs: true,
              decl: false
            });
            continue;
          case Tag.Super:
            if (!root.ref) break;
            let classSym = root.ref.classId;
            if (!classSym) classSym = root.ref.classId = Kit.scope.newSym("C");
            yield* s.toks(

function* _restoreLabeledStatements() {
    for (const i of s.sub()) {
      if (
        i.enter &&
        i.value.stmt &&
        !i.value.eff &&
        i.value.savedLabs &&
        i.value.savedLabs.length
      ) {
        const lab = s.label();
        let pos = i.pos;
        for (const j of i.value.savedLabs) {
          yield s.enter(pos, Tag.LabeledStatement);
          yield s.tok(Tag.label, Tag.Identifier, { node: { name: j } });
          pos = Tag.body;
        }
        yield s.peel(Kit.setPos(i, Tag.body));
        yield* _restoreLabeledStatements();
        yield* lab();
        continue;
      }
      yield i;
    }
  }
}

function* walk() {
    for (const i of s.sub()) {
      if (i.enter) {
        switch (i.type) {
          case byVal:
          case byRef:
            for (const i of s.sub()) {
              if (i.enter) {
                if (i.type !== Tag.Identifier || i.value.sym)
                  throw s.error("expected list of declared identifiers");
                i.value.sym.byVal = i.type === byVal;
                i.value.sym.byValStrict = true;
              }
            }
            s.close(i);
            continue;
          case Tag.Identifier:
            const si = i.value.sym;
            if (si != null && si.decl) {
              const symRoot = si.declScope;
              si.global = !symRoot || symRoot === top;
              si.track = !!s.track;
              if (si.byVal == null) si.byVal = !si.global && s.opts.state;
              si.singleAssign = undefined;
            }

root.track = false;
    for (const i of s.sub()) {
      if (i.enter) {
        switch (i.type) {
          case Tag.Super:
            supers.add(root);
            break;
          case Tag.FunctionDeclaration:
          case Tag.ArrowFunctionExpression:
          case Tag.FunctionExpression:
          case Tag.ObjectMethod:
          case Tag.ClassMethod:
            i.value.parentScope = root;
            collectScopes(i.value);
            break;
          case Tag.Identifier:
            const si = i.value.sym;
            if (si != null) {
              const { lhs } = i.value;
              const symRoot = si.declScope;
              if (!symRoot) break;
              if (i.value.decl) {
                symRoot.scopeDecls.add(si);
                allDecls.push(i.value);
                si.singleAssign = si.singleAssign == null ? lhs : false;
              } else {
                i.value.ext = false;
                if (lhs) si.singleAssign = false;
                const decl = si.declScope;
                if (decl !== root) {
                  (si.refScopes || (si.refScopes = new Set())).add(root);
                  capt.add(si);

case Tag.VariableDeclaration:
              const kind = i.value.node.kind;
              i.value.node.kind = "var";
              const declarators = [];
              const stmt = i.pos !== Tag.init && i.pos !== Tag.left;
              sl.peel(i);
              sl.peel();
              for (const j of sl.sub()) {
                invariant(j.enter);
                invariant(j.type === Tag.VariableDeclarator);
                let hasInit = false;
                const asgn = [];
                const id = [...sl.one()];
                asgn.push(...id);
                for (const j of id) {
                  if (j.enter && j.type === Tag.Identifier && j.value.decl) {
                    const sym = j.value.sym;
                    if (!sym.noDecl && !decls.has(sym)) {
                      decls.set(sym, { raw: null, node: j.value.node });
                    }
                    j.value.decl = false;
                  }
                }
                if (sl.cur().pos === Tag.init) {
                  asgn.push(...Kit.reposOne(sl.one(), Tag.right));
                  hasInit = true;
                } else if (kind === "let" && i.pos !== Tag.left) {
                  asgn.push(
                    sl.tok(Tag.right, Tag.Identifier, {
                      sym: Kit.scope.undefinedSym
                    })
                  );

function* prepare(s) {
    const stack = [];
    const si = lookahead(s);
    for (const i of si) {
      let key = false;
      switch (i.pos) {
        case Tag.label:
          if (i.enter) skip(sub(si));
          continue;
        case Tag.id:
          key = true;
          break;
        case Tag.property:
        case Tag.key:
          if (i.enter && i.type === Tag.Identifier) {
            const f = stack[0];
            if (f && f.computed) key = true;
          }
          break;
      }
      if (i.enter) {
        const tv = tagValue(i.pos, i.type, { node: i.value.node });
        if (key) tv.expr = false;
        stack.unshift(tv);
      }
      yield {
        enter: i.enter,
        leave: i.leave,
        type: i.type,
        pos: i.pos,
        value: stack[0]