How to create bridge class of a class that has non static methods

[Noobware1]

as the question says i don't know how to create new bridge class consisting of non-static methods which are depended on a single dynamic fleld;

here is some example of the code i am working with

import 'package:dart_eval/dart_eval.dart';
import 'package:dart_eval/dart_eval_bridge.dart';
import 'package:dart_eval/stdlib/core.dart';
import 'package:extenstions_test/constants/bridge.dart';
import 'package:extenstions_test/extenstions/iterable.dart';
import 'package:ok_http_dart/dom.dart';
import 'package:ok_http_dart/ok_http_dart.dart';

class DocumentObject {
  final dynamic document;

  const DocumentObject(this.document);

  List<ElementObject> select(String selector) {
    if (document is Document) {
      return (document as Document).querySelectorAll(selector).mapAsList(
          (e) => ElementObject(text: e.text, attributes: e.attributes));
    }
    return [];
  }

  ElementObject? selectFirst(String selector) {
    if (document is Document) {
      final element = (document as Document).querySelector(selector);
      if (element == null) {
        return null;
      }
      return ElementObject(text: element.text, attributes: element.attributes);
    }
    return null;
  }
}

class ElementObject {
  final String text;
  final dynamic attributes;

  ElementObject({required this.text, required this.attributes});

  String attr(String attr) {
    try {
      return attributes[attr];
    } catch (e) {
      return '';
    }
  }
}

class 
$ElementObject implements ElementObject, $Instance {
  static const $type =
      BridgeTypeRef(BridgeTypeSpec(bridgeLibary, 'ElementObject'));

  static const $declaration = BridgeClassDef(BridgeClassType($type),
      constructors: {
        '': BridgeConstructorDef(
          BridgeFunctionDef(returns: BridgeTypeAnnotation($type), namedParams: [
            BridgeParameter(
                'text',
                BridgeTypeAnnotation(
                    BridgeTypeRef.type(RuntimeTypes.stringType)),
                false),
            BridgeParameter(
                'attributes',
                BridgeTypeAnnotation(
                    BridgeTypeRef.type(RuntimeTypes.dynamicType)),
                false)
          ], params: []),
        )
      },
      fields: {
        'text': BridgeFieldDef(
          BridgeTypeAnnotation(
            BridgeTypeRef.type(RuntimeTypes.stringType),
          ),
        ),
        'attributes': BridgeFieldDef(
          BridgeTypeAnnotation(BridgeTypeRef.type(RuntimeTypes.dynamicType)),
        )
      },
      methods: {
        'attr': BridgeMethodDef(
          BridgeFunctionDef(
              returns: BridgeTypeAnnotation(
                  BridgeTypeRef.type(RuntimeTypes.stringType)),
              params: [
                BridgeParameter(
                    'attr',
                    BridgeTypeAnnotation(
                        BridgeTypeRef.type(RuntimeTypes.stringType)),
                    false)
              ]),
          isStatic: false,
        ),
      },
      wrap: true);

  @override
  $Value? $getProperty(Runtime runtime, String identifier) {
    switch (identifier) {
      case 'attributes':
        return $Object($value.attributes);
      case 'text':
        return $String($value.text);
      case 'attr':
        return $Function(_attr);
      default:
        return null;
    }
  }

  @override
  int $getRuntimeType(Runtime runtime) => runtime.lookupType($type.spec!);

  @override
  get $reified => $value;

  @override
  void $setProperty(Runtime runtime, String identifier, $Value value) {}

  $ElementObject.wrap(this.$value);

  @override
  final ElementObject $value;

  @override
  String attr(String attr) => $value.attr(attr);

  @override
  get attributes => $value.attributes;

  @override
  String get text => $value.text;

  static $Value? $new(
      final Runtime runtime, final $Value? target, final List<$Value?> args) {
    return $ElementObject.wrap(
        ElementObject(text: args[0]?.$value, attributes: args[1]?.$value));
  }

  static $Value? _attr(
      final Runtime runtime, final $Value? target, final List<$Value?> args) {
    var a = target!.$value as ElementObject;
    return $String(a.attr(args[0]?.$value));
  }
}

class $DocumentObject extends DocumentObject with $Bridge {
  $DocumentObject(super.document);

  static const $type =
      BridgeTypeRef(BridgeTypeSpec(bridgeLibary, 'DocumentObject'));

  static const $declaration = BridgeClassDef(
    BridgeClassType($type),
    constructors: {
      '': BridgeConstructorDef(BridgeFunctionDef(
          returns: BridgeTypeAnnotation($type),
          namedParams: [],
          params: [
            BridgeParameter(
                'document',
                BridgeTypeAnnotation(
                    BridgeTypeRef.type(RuntimeTypes.dynamicType)),
                false)
          ]))
    },
    methods: {
      'select': BridgeMethodDef(BridgeFunctionDef(
        returns: BridgeTypeAnnotation(
            BridgeTypeRef(CoreTypes.list, [$ElementObject.$type])),
        params: [
          BridgeParameter(
              'selector',
              BridgeTypeAnnotation(BridgeTypeRef.type(RuntimeTypes.stringType)),
              false),
        ],
      )),
      'selectFirst': BridgeMethodDef(BridgeFunctionDef(
        returns: BridgeTypeAnnotation($ElementObject.$type, nullable: true),
        params: [
          BridgeParameter(
              'selector',
              BridgeTypeAnnotation(BridgeTypeRef.type(RuntimeTypes.stringType)),
              false),
        ],
      )),
    },
    fields: {
      'document': BridgeFieldDef(
        BridgeTypeAnnotation(BridgeTypeRef.type(RuntimeTypes.dynamicType)),
      )
    },
    getters: {},
    setters: {},
    bridge: true,
  );

  static $DocumentObject $construct(
      Runtime runtime, $Value? target, List<$Value?> args) {
    return $DocumentObject(args[0]?.$value);
  }

  static $List _select(Runtime runtime, $Value? target, List<$Value?> args) {
    return $List.wrap((target as DocumentObject)
        .select(args[0]?.$value)
        .mapAsList((it) => $ElementObject.wrap(it)));
  }

  static $ElementObject? _selectFirst(
      Runtime runtime, $Value? target, List<$Value?> args) {
    final value = (target as DocumentObject).selectFirst(args[0]?.$value);

    if (value != null) {
      return $ElementObject.wrap(value);
    }
    return null;
  }

  @override
  $Value? $bridgeGet(String identifier) {
    switch (identifier) {
      case 'select':
        return $Function(_select);
      case 'selectFirst':
        return $Function(_selectFirst);
      case 'document':
        return $DocumentObject($value);
      default:
        return null;
    }
  }

  

  @override
  void $bridgeSet(String identifier, $Value value) {}
}

currently i am not able to use this as it throws an error.