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

node: { operator: "=" }
                  });
                  yield sl.tok(Tag.left, Tag.Identifier, {
                    sym,
                    lhs: true,
                    rhs: false,
                    decl: false
                  });
                  yield* init;
                  yield* sl.leave();
                  yield* sl.leave();
                }
              }
              // babel's hoist re-hack
              if (i.value.babelHoistReHack) {
                yield sl.enter(Tag.push, Tag.BlockStatement);
                yield sl.enter(Tag.body, Tag.Array);
                yield* _restoreDecls(sl.sub());
                yield* sl.leave();
                yield* sl.leave();
              }
              break;
            }
          }
        }
      }
    }
  }
}

(function*() {
          let i;
          for (i of loc) {
            if (i.pos === Tag.body) break;
            yield i;
          }
          if (i.type !== Tag.BlockStatement) {
            const lab = loc.label();
            yield loc.enter(Tag.body, Tag.BlockStatement, {
              decls: i.value.decls
            });
            yield loc.enter(Tag.body, Tag.Array);
            yield loc.enter(Tag.push, Tag.ReturnStatement);
            yield loc.peel(Kit.setPos(i, Tag.argument));
            yield* loc.sub();
            yield* lab();
          } else yield i;
          yield* loc;
        })()
      )

(function*() {
          let i;
          for (i of loc) {
            if (i.pos === Tag.body) break;
            yield i;
          }
          if (i.type !== Tag.BlockStatement) {
            const lab = loc.label();
            yield loc.enter(Tag.body, Tag.BlockStatement, {
              decls: i.value.decls
            });
            yield loc.enter(Tag.body, Tag.Array);
            yield loc.enter(Tag.push, Tag.ReturnStatement);
            yield loc.peel(Kit.setPos(i, Tag.argument));
            yield* loc.sub();
            yield* lab();
          } else yield i;
          yield* loc;
        })()
      )

function walk(labs, map, brkLab) {
      for (const i of sl.sub()) {
        if (i.enter) {
          i.value.ctrl = null;
          switch (i.type) {
            case Tag.LabeledStatement:
              walk([...labs, i.value.node.label.name], map, brkLab);
              break;
            case Tag.BlockStatement:
              let bmap = map;
              if (labs.length) {
                bmap = new Map(map);
                i.value.ctrl = labs[0];
                i.value.labs = [...labs];
                for (const j of labs) bmap.set(j, i.value);
              }
              walk([], bmap, brkLab);
              break;
            case Tag.WhileStatement:
            case Tag.DoWhileStatement:
            case Tag.ForStatement:
            case Tag.SwitchStatement:
            case Tag.ForInStatement:
            case Tag.ForOfStatement:
              const lmap = new Map(map);

function* walk() {
          for (const i of sl.sub()) {
            if (i.enter && i.type === Tag.BlockStatement && i.value.eff) {
              const lab = sl.label();
              sl.peel(i);
              let directives = sl.cur().pos === Tag.directives && [...sl.one()];
              if (directives.length <= 2) directives = null;
              sl.peel();
              const top = i.value.ctrl === "#ret";
              const node = { top };
              const start = sl.enter(i.pos, Block.chain, {
                node,
                sym: top ? scopeId : blockId,
                ctrl: i.value.ctrl,
                opts: i.value.opts,
                directives,
                optsAssign: i.value.optsAssign,
                root,
                stmt: true,

export function* peelBlockFrom(s) {
  const i = s.cur();
  if (i != null && i.type === Tag.BlockStatement) {
    yield s.peel();
    yield* s.peelTo(Tag.body);
  } else {
    yield s.enter(i.pos, Tag.BlockStatement);
    yield s.enter(Tag.body, Tag.Array);
    yield s.enter(Tag.push, Subst);
  }
}

)
              );
              yield b.enter(Tag.body, Tag.Array);
              yield b.enter(Tag.push, Kit.Subst);
              yield* walk();
              yield* lab();
            }
            break;
          default:
            if (i.type.ctrl) {
              if (i.type.arg === "b") {
                if (i.enter) {
                  yield D.copyComment(
                    i,
                    D.setComment(
                      b.enter(i.pos, Tag.BlockStatement),
                      symName(i.type),
                      "color:blue;font-size:large"
                    )
                  );
                  yield b.enter(Tag.body, Tag.Array);
                  yield b.enter(Tag.push, Kit.Subst);
                  yield* walk();
                  yield* b.leave();
                  yield* b.leave();
                  yield* b.leave();
                }
                break;
              }
            }
            yield i;
        }

const b = sl.take();
    if (b.value.expr) {
      yield hl("block", sl.enter(Tag.body, Tag.ExpressionStatement));
      yield sl.peel(Kit.setPos(b, Tag.expression));
    } else {
      if (
        symName(b.type) === "castToBlock" ||
        symName(b.type) === "castToBody"
      ) {
        yield* toBlock(pos);
        return;
      }
      if (b.type === Tag.BlockStatement) {
        yield sl.peel(Kit.setPos(b, pos));
      } else {
        yield sl.enter(pos, Tag.BlockStatement);
        yield sl.enter(Tag.body, Tag.Array);
        yield sl.peel(Kit.setPos(b, Tag.push));
      }
    }
    yield* walk();
    yield* lab();
  }
  function* walk() {

export function* openBlock(pos, s) {
  yield s.enter(pos, Tag.BlockStatement);
  yield s.enter(Tag.push, Tag.Array);
}