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

function* toBlock(pos) {
    const lab = sl.label();
    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));
      }

}
                if (hasInit) {
                  id[0].pos = id[id.length - 1].pos = Tag.left;
                  declarators.push(asgn);
                } else {
                  if (i.pos === Tag.left) {
                    id[0].pos = id[id.length - 1].pos = i.pos;
                    yield* id;
                  } else yield sl.tok(i.pos, Tag.Null);
                }
                sl.close(j);
              }
              if (declarators.length) {
                if (stmt && i.pos === Tag.push) {
                  for (const k of declarators) {
                    yield sl.enter(Tag.push, Tag.ExpressionStatement);
                    yield sl.enter(Tag.expression, Tag.AssignmentExpression, {
                      node: { operator: "=" }
                    });
                    yield* k;
                    yield* sl.leave();
                    yield* sl.leave();
                  }
                } else {
                  const lab = sl.label();
                  if (stmt) yield sl.enter(i.pos, Tag.ExpressionStatement);
                  let pos = stmt ? Tag.expression : i.pos;
                  if (declarators.length !== 1) {
                    yield sl.enter(pos, Tag.SequenceExpression);
                    yield sl.enter(Tag.expressions, Tag.Array);
                    pos = Tag.push;
                  }

function* removeSubScopes(s) {
  for (const i of s) {
    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;
  }
}