fromFunctionaddresscast==hashCode dimension1 dimension2 dimension3 dimension4 dimension5 dimensionsvariableLengthvariableLengthLengthnativeFunctionclosekeepIsolateAlive majorVersion minorVersion postCObject newNativePortcloseNativePortinitializeApiDLDatasymbolassetIdisLeaf addressOfid sizeOfnullptrPointerArray _ArraySizeNativeCallable Dart_CObjectDart_NativeMessageHandler NativeApiNative DefaultAssetGSincedartffiintSizedNativeTypeNever fromAddresspragma NativeTypelistener fromFunction isolateLocalNativeFunctionFunctionDartRepresentationOfObjectbooladdresshashCode _CompoundStructListAllocatorAlloccall AllocatorallocateNFisLeafIsolatecloseUnsupportedErrorSendPortcallbackvoidInt8 Deprecated finalizertokenInt8ListNativeFinalizerFunctionVoidInt16 Int16ListInt32 Int32ListInt64 Int64ListUint8 Uint8ListUint16 Uint16ListUint32 Uint32ListUint64 Uint64ListFloatdouble Float32ListDouble Float64ListBoolTrefUnionAbiSpecificInteger TypedData ReceivePortRawReceivePortOpaqueStringassetIdSizedNativeType _CompoundArrayOpaque:k ɁSincedart:_internal dart:isolatedart:typed_dataTkN׀؁-1y}Ձ2Ki˂߂"QU˃̄:qrӄ6[܆ULÈ]ASωxӊԋ2[}#%&GVόՌ!LRjōˍ,BXĎҎgm DҐؑ$c(.ci•ȕ!'tɗ5NX`jp V\'H\p4Yݛ}ߛ Uxz{ל ";<[\ܝ%:Odyߞ0Kf*/zӡQ¡ 4I^âģQlأI~ ZI9ը!m$&'ko *8rתݫ)v9KQ>oʮ@DE+ek>۲ _-3FLZu>oӵB{ Sжڷ&,zɷ6<]ek#)XԺ7ǺNRSǼBCz˼ۼRbcC.12w׿@*@v@@@@AAA[AAABB%BrBBBC/CWCCCCCD3D~DDEE<ELEjEEEF FF;FAFxFGGGdGGGGHHHcHiHHHI6IKIQIIJJ;JMJJJJJKK.KfKlKLLL:LTLUL{L|LLM#MpMvMMMNN"NqNNNO$O%OaOOOOP+P1PiPQ QQSQtQQQR R RHRNRvR|RSSVS\SSSSTT[T\TTTU%U+UwUUUV-V[VaVVVWW(W.W0W1WwWWWX/X|XXXXXXYBYHYYYZZ=Z>ZZZ[2[8[d[[[[\&\d\e\\\])]}]]]]^^A^^^^^^_(_u__``7`G`e```aaajaaabbbTbbbcc#c5ctcccccddNdTdddddeeeFemeneeef&f'fcffffg-g3gkgh hhUhvhhhiiiJiPixi~ijjXj^jjjjkk]k^kkkl'l-lylllm/m]mcmmmnn*n0n2n3nynnno(otoooooppTpppqqqfqqqr#rKrtrrrrs+swsstt6tFtdtttu uu8u>uvuvvvdvvvvwwwewkwwwx9xNxTxxyy?yQyyyyyzz5zezkz{ {{;{U{V{|{}{{||l|r|||}}}h}}}~~~X~~~~%+d Pq HNv|Y_ `a+1}3ag/5783?E<=,2^!`a(}B,z=Mk%r ] -?~#SYDklZ'-fRs JPx~[a"bc-35ci 179:NTV p EmM7Xh,2Z`:@?@ [pv?Eq^#$^d'^_,-hnIONOF 7c>nt)v Ksy{|12YZ$%a(.e Mn~?EmsJPMOP\k.=d6]^/0dfg9;<zO^#2Y 4^_–˜™ 12gijxà$pęğĮĴEK_łŤŬŶż Yƪ/(Y_Ȭ!'6<\ɗ /7AGʖ5hn˺ Ry{|̴̊8̈́ͭͳ#[auΙλ"pFЖ@qw9?NTtү%GOY_ӮMԀԆ"jՑՓՔբP֜;sy׍ױ:؈ ^ٮ .Zڋڑ*SYhnێ Bdlv|jݝݣ?އޯޱ޲#p߼ \]/5ACDR~Nw}'-Af=cCI  &F#-3!TZ>eghv(tMSgd:f$ioBC"pj9tuNT;A$LR;A)8r,{U :@)NO <no5;o Qr @&Guwx@F %r+HI06  B H     7 _      D     - . e k     g m  B\k"#Y(P|}5V\X^5D3Bx ]l EGH:<=  @BCQc%Qd k =C'JLM[c ' - Y i      !!!!d!""6"<""# #C#E#F#T###$ $Z$|$$$$$%%"%L%\%t%|%%%%%%&&S&&'%'+'w'((2(4(5(C(a((()8)Z)`))*H*z*****+&+,+X+h+++++++++, ,A,i,,,,,,,-M--..%.q./ /,/.///=/a///080Z0`001H1z111112(2.2Z2k22222222333L3t3333344 4[445-535566:6<6=6K6k6667B7d7j788R8a8g8v8|88899-9=9V9\9l9999999::@:o:w:::;$;u;;;>>Z>>>>>? ??F?G????@ @+@e@k@@@@A*A0ApAAAAB B+BFBBBBBCCGCCCCCCDDWDDDDDE7ERESEEEFFFF`FdFFFGGhGGGH0HcHHIEIbIIJ&J*JzJKK2K6KKKL=LLMMnMMMMMNN9N=NRNoNsNNNNO ONOxOOOOP=PyP}PPPQ8QQQRR RTR|RRRRRSSSS'S-SHSSSSSSTT6T7TTTTU)UvUUUUVV@VfVpVvVVVVVWWW!WOWuWWWWWXX@XJXPXXXYYRYkYlYYYZBZZ[&[v[\\_\\]]]P]e]f]w]]]]]]]^C^^^_-_x__````,`f`p`v``aaa+a1aiaoaaaabb!b+b1bub{bbbbcc<cBcPcicoccccd dYddddde.e_eaebeeeef:f~fggNg`gdgghFhJhhhii i$iPiti|iiiiiijjjjGjkjsjwjjjjk0k?kZkkkkkkk恧/// Foreign Function Interface for interoperability with the C programming language. /// /// For further details, please see: https://dart.dev/server/c-interop. /// /// {@category VM}ɁӁ 2Ki˂rF/// Represents a pointer into the native C memory. Cannot be extended.8Suv"/// Construction from raw integer.nb/// Access to the raw pointer value. /// On 32-bit systems, the upper 32-bits of the result are 0.r to a Pointer.ր֋8/// Equality for Pointers only depends on their address." * фӄԄڄی&Sb /// A fixed-sized array of [T]s.hhB/// Annotation to specify [Array] dimensions in [Struct]s. /// /// ```dart /// final class MyStruct extends Struct { /// @Array(8) /// external Array inlineArray; /// /// @Array(2, 2, 2) /// external Array>> threeDimensionalInlineArray; /// } /// ``` /// /// Do not invoke in normal code. !27HM^c YZ_/// Annotation to specify [Array] dimensions in [Struct]s. /// /// ```dart /// final class MyStruct extends Struct { /// @Array.multi([2, 2, 2]) /// external Array>> threeDimensionalInlineArray; /// /// @Array.multi([2, 2, 2, 2, 2, 2, 2, 2]) /// external Array>>>>>>> eightDimensionalInlineArray; /// } /// ``` /// /// Do not invoke in normal code.`k&<=E /// Annotation to specify a variable length [Array] in [Struct]s. /// /// Can only be used on the last field of a struct. The last field of the /// struct is _not_ taken into account in [sizeOf]. Using an /// [AllocatorAlloc.call] will _not_ allocate any backing storage for the /// variable length array. Instead use [Allocator.allocate] and calculate the /// required number of bytes manually. /// /// ```dart /// import 'dart:ffi'; /// import 'package:ffi/ffi.dart'; /// /// final class MyStruct extends Struct { /// @Size() /// external int length; /// /// @Array.variable() /// external Array inlineArray; /// /// static Pointer allocate(Allocator allocator, int length) { /// final lengthInBytes = sizeOf() + sizeOf() * length; /// final result = allocator.allocate(lengthInBytes); /// result.ref.length = length; /// return result; /// } /// } /// /// void main() { /// final myStruct = MyStruct.allocate(calloc, 10); /// } /// ``` /// /// The variable lenght is always the outermost dimension of the array. /// /// ```dart /// import 'dart:ffi'; /// import 'package:ffi/ffi.dart'; /// /// final class MyStruct extends Struct { /// @Size() /// external int length; /// /// @Array.variable(10, 10) /// external Array>> inlineArray; /// /// static Pointer allocate(Allocator allocator, int length) { /// final lengthInBytes = sizeOf() + sizeOf() * length * 100; /// final result = allocator.allocate(lengthInBytes); /// result.ref.length = length; /// return result; /// } /// } /// ``` /// /// Accessing variable length inline arrays of structs passed by value in FFI /// calls and callbacks is undefined behavior. Accessing variable length /// inline arrays in structs passed by value is undefined behavior in C. /// /// For more information about variable length inline arrays in C, please /// refer to: https://gcc.gnu.org/onlinedocs/gcc/Zero-Length.html. /// /// Do not invoke in normal code.LQ`ety% ./<./// Annotation to a variable length [Array] in [Struct]s. /// /// ```dart /// final class MyStruct extends Struct { /// @Array.variableMulti([2, 2]) /// external Array>> threeDimensionalInlineArray; /// } /// /// final class MyStruct2 extends Struct { /// @Array.variableMulti([2, 2, 2, 2, 2, 2, 2]) /// external Array>>>>>>> eightDimensionalInlineArray; /// } /// ``` /// /// The variable lenght is always the outermost dimension of the array. /// /// Do not invoke in normal code.=H GHMTN{} )/>DSYhnǞȞ (*C8E^S`}n#)8>MS qfsƁ0֢ע dYftУţң $/>O%'M/// A native callable which listens for calls to a native function. /// /// Creates a native function linked to a Dart function, so that calling the /// native function will call the Dart function in some way, with the arguments /// converted to Dart values.\\t/// Constructs a [NativeCallable] that must be invoked from the same thread /// that created it. /// /// If an exception is thrown by the [callback], the native function will /// return the `exceptionalReturn`, which must be assignable to the return /// type of the [callback]. /// /// The returned function address can only be invoked on the mutator (main) /// thread of the current isolate. It will abort the process if invoked on any /// other thread. Use [NativeCallable.listener] to create callbacks that can /// be invoked from any thread. /// /// Unlike [Pointer.fromFunction], [NativeCallable]s can be constructed from /// any Dart function or closure, not just static or top level functions. /// /// This callback must be [close]d when it is no longer needed. The [Isolate] /// that created the callback will be kept alive until [close] is called. /// After [NativeCallable.close] is called, invoking the [nativeFunction] from /// native code will cause undefined behavior.,G Ŋ/// Constructs a [NativeCallable] that can be invoked from any thread. /// /// When the native code invokes the function [nativeFunction], the arguments /// will be sent over a [SendPort] to the [Isolate] that created the /// [NativeCallable], and the callback will be invoked. /// /// The native code does not wait for a response from the callback, so only /// functions returning void are supported. /// /// The callback will be invoked at some time in the future. The native caller /// cannot assume the callback will be run immediately. Resources passed to /// the callback (such as pointers to malloc'd memory, or output parameters) /// must be valid until the call completes. /// /// This callback must be [close]d when it is no longer needed. The [Isolate] /// that created the callback will be kept alive until [close] is called. /// After [NativeCallable.close] is called, invoking the [nativeFunction] from /// native code will cause undefined behavior. /// /// For example: /// /// ```dart /// import 'dart:async'; /// import 'dart:ffi'; /// import 'package:ffi/ffi.dart'; /// /// // Processes a simple HTTP GET request using a native HTTP library that /// // processes the request on a background thread. /// Future httpGet(String uri) async { /// final uriPointer = uri.toNativeUtf8(); /// /// // Create the NativeCallable.listener. /// final completer = Completer(); /// late final NativeCallable callback; /// void onResponse(Pointer responsePointer) { /// completer.complete(responsePointer.toDartString()); /// calloc.free(responsePointer); /// calloc.free(uriPointer); /// /// // Remember to close the NativeCallable once the native API is /// // finished with it, otherwise this isolate will stay alive /// // indefinitely. /// callback.close(); /// } /// callback = NativeCallable.listener(onResponse); /// /// // Invoke the native HTTP API. Our example HTTP library processes our /// // request on a background thread, and calls the callback on that same /// // thread when it receives the response. /// nativeHttpGet(uriPointer, callback.nativeFunction); /// /// return completer.future; /// } /// /// // Load the native functions from a DynamicLibrary. /// final DynamicLibrary dylib = DynamicLibrary.process(); /// typedef NativeHttpCallback = Void Function(Pointer); /// /// typedef HttpGetFunction = void Function( /// Pointer, Pointer>); /// typedef HttpGetNativeFunction = Void Function( /// Pointer, Pointer>); /// final nativeHttpGet = /// dylib.lookupFunction( /// 'http_get'); /// ```,ͺκe@/// Whether this [NativeCallable] keeps its [Isolate] alive. /// /// By default, [NativeCallable]s keep the [Isolate] that created them alive /// until [close] is called. If [keepIsolateAlive] is set to `false`, the /// isolate may exit even if the [NativeCallable] isn't closed.U2/// The native function pointer which can be used to invoke the `callback` /// passed to the constructor. /// /// This pointer must not be read after the callable has been [close]d.EY/// Closes this callback and releases its resources. /// /// Further calls to existing [nativeFunction]s will result in undefined /// behavior. /// /// Subsequent calls to [close] will be ignored. /// /// It is safe to call [close] inside the [callback].*+061>_?'&/// Opaque, not exposing it's members.? ?????x@b/// Utilities for accessing the Dart VM API from Dart code or /// from C code via `dart_api_dl.h`.@-@y/// On breaking changes the major version is increased. /// /// The versioning covers the API surface in `dart_api_dl.h`.@@@@@@A/// On backwards compatible changes the minor version is increased. /// /// The versioning covers the API surface in `dart_api_dl.h`.ArAsAxA~AyAB{/// A function pointer to /// `bool Dart_PostCObject(Dart_Port port_id, Dart_CObject* message)` /// in `dart_native_api.h`.BDq/// A function pointer to /// ```c /// Dart_Port Dart_NewNativePort(const char* name, /// Dart_NativeMessageHandler handler, /// bool handle_concurrently) /// ``` /// in `dart_native_api.h`.DEAo/// A function pointer to /// `bool Dart_CloseNativePort(Dart_Port native_port_id)` /// in `dart_native_api.h`.EUEo/// Pass this to `Dart_InitializeApiDL` in your native code to enable using the /// symbols in `dart_api_dl.h`.EEEEE??@@@FMP/// Annotation binding an external declaration to its native implementation. /// /// Can only be applied to `external` declarations of static and top-level /// functions and variables. /// /// A [Native]-annotated `external` function is implemented by native code. /// The implementation is found in the native library denoted by [assetId]. /// Similarly, a [Native]-annotated `external` variable is implemented by /// reading from or writing to native memory. /// /// The compiler and/or runtime provides a binding from [assetId] to native /// library, which depends on the target platform. /// The compiler/runtime can then resolve/lookup symbols (identifiers) /// against the native library, to find a native function or a native global /// variable, and bind an `external` Dart function or variable declaration to /// that native declaration. /// By default, the runtime expects a native symbol with the same name as the /// annotated function or variable in Dart. This can be overridden with the /// [symbol] parameter on the annotation. /// /// If this annotation is used on a function, then the type argument [T] to the /// [Native] annotation must be a function type representing the native /// function's parameter and return types. The parameter and return types must /// be subtypes of [NativeType]. /// /// If this annotation is used on an external variable, then the type argument /// [T] must be a compatible native type. For example, an [int] field can be /// annotated with [Int32]. /// If the type argument to `@Native` is omitted, it defaults to the Dart type /// of the annotated declaration, which *must* then be a native type too. /// This will never work for function declarations, but can apply to variables /// whose type is some of the types of this library, such as [Pointer]. /// For native global variables that cannot be re-assigned, a final variable in /// Dart or a getter can be used to prevent assignments to the native field. /// /// Example: /// /// ```dart template:top /// @Native() /// external int sum(int a, int b); /// /// @Native() /// external int aGlobalInt; /// /// @Native() /// external final Pointer aGlobalString; /// ``` /// /// Calling a `@Native` function, as well as reading or writing to a `@Native` /// variable, will try to resolve the [symbol] in (in the order): /// 1. the provided or default [assetId], /// 2. the native resolver set with `Dart_SetFfiNativeResolver` in /// `dart_api.h`, and /// 3. the current process. /// /// At least one of those three *must* provide a binding for the symbol, /// otherwise the method call or the variable access fails. /// /// NOTE: This is an experimental feature and may change in the future.PP]hP]n]t]{ ]]]] ]]QÂqT.0/// The native symbol to be resolved, if not using the default. /// /// If not specified, the default symbol used for native function lookup /// is the annotated function's name. /// /// Example: /// /// ```dart template:top /// @Native() /// external int sum(int a, int b); /// ``` /// /// Example 2: /// /// ```dart template:top /// @Native(symbol: 'sum') /// external int sum(int a, int b); /// ``` /// /// The above two examples are equivalent. /// /// Prefer omitting the [symbol] when possible.T90Yb/// The ID of the asset in which [symbol] is resolved, if not using the /// default. /// /// If no asset name is specified, the default is to use an asset ID /// specified using an [DefaultAsset] annotation on the current library's /// `library` declaration, and if there is no [DefaultAsset] annotation on /// the current library, the library's URI (as a string) is used instead. /// /// Example (file `package:a/a.dart`): /// /// ```dart template:top /// @Native() /// external int sum(int a, int b); /// ``` /// /// Example 2 (file `package:a/a.dart`): /// /// ```dart template:none /// @DefaultAsset('package:a/a.dart') /// library a; /// /// import 'dart:ffi'; /// /// @Native() /// external int sum(int a, int b); /// ``` /// /// Example 3 (file `package:a/a.dart`): /// /// ```dart template:top /// @Native(assetId: 'package:a/a.dart') /// external int sum(int a, int b); /// ``` /// /// The above three examples are all equivalent. /// /// Prefer using the library URI as an asset name over specifying it. /// Prefer using an [DefaultAsset] on the `library` declaration /// over specifying the asset name in a [Native] annotation.Yn]]/// Whether the function is a leaf function. /// /// Leaf functions are small, short-running, non-blocking functions which are /// not allowed to call back into Dart or use any Dart VM APIs. Leaf functions /// are invoked bypassing some of the heavier parts of the standard /// Dart-to-Native calling sequence which reduces the invocation overhead, /// making leaf calls faster than non-leaf calls. However, this implies that a /// thread executing a leaf function can't cooperate with the Dart runtime. A /// long running or blocking leaf function will delay any operation which /// requires synchronization between all threads associated with an isolate /// group until after the leaf function returns. For example, if one isolate /// in a group is trying to perform a GC and a second isolate is blocked in a /// leaf call, then the first isolate will have to pause and wait until this /// leaf call returns. /// /// This value has no meaning for native fields.]e /// The native address of the implementation of [native]. /// /// When calling this function, the argument for [native] must be an /// expression denoting a variable or function declaration which is annotated /// with [Native]. /// For a variable declaration, the type [T] must be the same native type /// as the type argument to that `@Native` annotation. /// For a function declaration, the type [T] must be `NativeFunction` /// where `F` was the type argument to that `@Native` annotation. /// /// For example, for a native C library exposing a function: /// /// ```C /// #include /// int64_t sum(int64_t a, int64_t b) { return a + b; } /// ``` /// /// The following code binds `sum` to a Dart function declaration, and /// extracts the address of the native `sum` implementation: /// /// ```dart /// import 'dart:ffi'; /// /// typedef NativeAdd = Int64 Function(Int64, Int64); /// /// @Native() /// external int sum(int a, int b); /// /// void main() { /// Pointer> addressSum = Native.addressOf(sum); /// } /// ``` /// /// Similarly, for a native C library exposing a global variable: /// /// ```C /// const char* myString; /// ``` /// /// The following code binds `myString` to a top-level variable in Dart, and /// extracts the address of the underlying native field: /// /// ```dart /// import 'dart:ffi'; /// /// @Native() /// external Pointer myString; /// /// void main() { /// // This pointer points to the memory location where the loader has /// // placed the `myString` global itself. To get the string value, read /// // the myString field directly. /// Pointer> addressMyString = Native.addressOf(myString); /// } /// ```eee4(eW ddddde4e5eIeMeJPPPPPebkK/// Annotation specifying the default asset ID for the current library. /// /// The annotation applies only to `library` declarations. /// /// The compiler and/or runtime provides a binding from _asset ID_ to native /// library, which depends on the target platform and architecture. /// The compiler/runtime can resolve identifiers (symbols) /// against the native library, looking up native function implementations /// which are then used as the implementation of `external` Dart function /// declarations. /// /// If used as annotation on a `library` declaration, all [Native]-annotated /// external functions in this library will use the specified asset [id] /// for native function resolution (unless overridden by [Native.assetId]). /// /// If no [DefaultAsset] annotation is provided, the current library's URI /// is the default asset ID for [Native]-annotated external functions. /// /// Example (file `package:a/a.dart`): /// /// ```dart template:top /// @Native() /// external int sum(int a, int b); /// ``` /// /// Example 2 (file `package:a/a.dart`): /// /// ```dart template:none /// @DefaultAsset('package:a/a.dart') /// library a; /// /// import 'dart:ffi'; /// /// @Native() /// external int sum(int a, int b); /// ``` /// /// The above two examples are equivalent. /// /// Prefer using the library URI as asset name when possible. /// /// NOTE: This is an experimental feature and may change in the future.k%kkkkk\]kK/// The default asset name for [Native] external functions in this library.k0k1k6k=k71+TN/// Extension on [Pointer] specialized for the type argument [NativeFunction].ii~Ƀ/// Convert to Dart function, automatically marshalling the arguments and /// return value. /// /// [isLeaf] specifies whether the function is a leaf function. Leaf functions /// are small, short-running, non-blocking functions which are not allowed to /// call back into Dart or use any Dart VM APIs. Leaf functions are invoked /// bypassing some of the heavier parts of the standard Dart-to-Native calling /// sequence which reduces the invocation overhead, making leaf calls faster /// than non-leaf calls. However, this implies that a thread executing a leaf /// function can't cooperate with the Dart runtime. A long running or blocking /// leaf function will delay any operation which requires synchronization /// between all threads associated with an isolate group until after the leaf /// function returns. For example, if one isolate in a group is trying to /// perform a GC and a second isolate is blocked in a leaf call, then the /// first isolate will have to pause and wait until this leaf call returns./ Ԩը2D/// Extension on [Pointer] specialized for the type argument [Int8].@/// The 8-bit two's complement integer at [address]. /// /// A Dart integer is truncated to 8 bits (as if by `.toSigned(8)`) before /// being stored, and the 8-bit value is sign-extended when it is loaded.@#@@ @@A/// The 8-bit two's complement integer at `address + sizeOf() * index`. /// /// A Dart integer is truncated to 8 bits (as if by `.toSigned(8)`) before /// being stored, and the 8-bit value is sign-extended when it is loaded.A AAс B׀/// The 8-bit two's complement integer at `address + sizeOf() * index`. /// /// A Dart integer is truncated to 8 bits (as if by `.toSigned(8)`) before /// being stored, and the 8-bit value is sign-extended when it is loaded.B BB BBCg9/// Pointer arithmetic (takes element size into account).Cq CvC1C2C<CUC=CEn/// A pointer to the [offset]th [Int8] after this one. /// /// Returns a pointer to the [Int8] whose address is /// [offset] times the size of `Int8` after the address of this pointer. /// That is `(this + offset).address == this.address + offset * sizeOf()`. /// /// Also `(this + offset).value` is equivalent to `this[offset]`, /// and similarly for setting.E E E>E?EDEJEEENEOEUEhEVEՂEǴ/// A pointer to the [offset]th [Int8] before this one. /// /// Equivalent to `this + (-offset)`. /// /// Returns a pointer to the [Int8] whose address is /// [offset] times the size of `Int8` before the address of this pointer. /// That is, `(this - offset).address == this.address - offset * sizeOf()`. /// /// Also, `(this - offset).value` is equivalent to `this[-offset]`, /// and similarly for setting,G G GGGGGGGGGGHJ./// Creates a typed list view backed by memory in the address space. /// /// The returned view will allow access to the memory range from [address] /// to `address + sizeOf() * length`. /// /// The user has to ensure the memory range is accessible while using the /// returned list. /// /// If provided, [finalizer] will be run on the pointer once the typed list /// is GCed. If provided, [token] will be passed to [finalizer], otherwise /// the this pointer itself will be passed.J? JDJQ9JJ"J JQJRJWJ]JXJJJJJJrKE/// Extension on [Pointer] specialized for the type argument [Int16].K0#LM/// The 16-bit two's complement integer at [address]. /// /// A Dart integer is truncated to 16 bits (as if by `.toSigned(16)`) before /// being stored, and the 16-bit value is sign-extended when it is loaded. /// /// The [address] must be 2-byte aligned.LW#LiLo LtL~JM/// The 16-bit two's complement integer at `address + sizeOf() * index`. /// /// A Dart integer is truncated to 16 bits (as if by `.toSigned(16)`) before /// being stored, and the 16-bit value is sign-extended when it is loaded. /// /// The [address] must be 2-byte aligned.M MḾWO /// The 16-bit two's complement integer at `address + sizeOf() * index`. /// /// A Dart integer is truncated to 16 bits (as if by `.toSigned(16)`) before /// being stored, and the 16-bit value is sign-extended when it is loaded. /// /// The [address] must be 2-byte aligned.O OO OO'O9/// Pointer arithmetic (takes element size into account).O OOcOdOnOOoOQr/// A pointer to the [offset]th [Int16] after this one. /// /// Returns a pointer to the [Int16] whose address is /// [offset] times the size of `Int16` after the address of this pointer. /// That is `(this + offset).address == this.address + offset * sizeOf()`. /// /// Also `(this + offset).value` is equivalent to `this[offset]`, /// and similarly for setting.Q Q QvQwQ|QQ}QQQQQRKT /// A pointer to the [offset]th [Int16] before this one. /// /// Equivalent to `this + (-offset)`. /// /// Returns a pointer to the [Int16] whose address is /// [offset] times the size of `Int16` before the address of this pointer. /// That is, `(this - offset).address == this.address - offset * sizeOf()`. /// /// Also, `(this - offset).value` is equivalent to `this[-offset]`, /// and similarly for setting,T T SSSSSSSSSST^V/// Creates a typed list view backed by memory in the address space. /// /// The returned view will allow access to the memory range from [address] /// to `address + sizeOf() * length`. /// /// The user has to ensure the memory range is accessible while using the /// returned list. /// /// If provided, [finalizer] will be run on the pointer once the typed list /// is GCed. If provided, [token] will be passed to [finalizer], otherwise /// the this pointer itself will be passed. /// /// The [address] must be 2-byte aligned.V VV9VW"W" VVVVVWWW WW W1rWE/// Extension on [Pointer] specialized for the type argument [Int32].W#X/// The 32-bit two's complement integer at [address]. /// /// A Dart integer is truncated to 32 bits (as if by `.toSigned(32)`) before /// being stored, and the 32-bit value is sign-extended when it is loaded. /// /// The [address] must be 4-byte aligned.X#XX XXJZ./// The 32-bit two's complement integer at `address + sizeOf() * index`. /// /// A Dart integer is truncated to 32 bits (as if by `.toSigned(32)`) before /// being stored, and the 32-bit value is sign-extended when it is loaded. /// /// The [address] must be 4-byte aligned.Z1 Z6Z@W[}/// The 32-bit two's complement integer at `address + sizeOf() * index`. /// /// A Dart integer is truncated to 32 bits (as if by `.toSigned(32)`) before /// being stored, and the 32-bit value is sign-extended when it is loaded. /// /// The [address] must be 4-byte aligned.[ [[ [[\9/// Pointer arithmetic (takes element size into account).\ \[[[[[\g^0r/// A pointer to the [offset]th [Int32] after this one. /// /// Returns a pointer to the [Int32] whose address is /// [offset] times the size of `Int32` after the address of this pointer. /// That is `(this + offset).address == this.address + offset * sizeOf()`. /// /// Also `(this + offset).value` is equivalent to `this[offset]`, /// and similarly for setting.^2 ^7 ]]]]]]]^^^^K`/// A pointer to the [offset]th [Int32] before this one. /// /// Equivalent to `this + (-offset)`. /// /// Returns a pointer to the [Int32] whose address is /// [offset] times the size of `Int32` before the address of this pointer. /// That is, `(this - offset).address == this.address - offset * sizeOf()`. /// /// Also, `(this - offset).value` is equivalent to `this[-offset]`, /// and similarly for setting,` ` `9`:`?`E`@`I`J`P`c`Q`҂c/// Creates a typed list view backed by memory in the address space. /// /// The returned view will allow access to the memory range from [address] /// to `address + sizeOf() * length`. /// /// The user has to ensure the memory range is accessible while using the /// returned list. /// /// If provided, [finalizer] will be run on the pointer once the typed list /// is GCed. If provided, [token] will be passed to [finalizer], otherwise /// the this pointer itself will be passed. /// /// The [address] must be 4-byte aligned.c' c,c99cjcx"c c9c:c?cEc@cxcyc~ccccE/// Extension on [Pointer] specialized for the type argument [Int64].ddc/// The 64-bit two's complement integer at [address]. /// /// The [address] must be 8-byte aligned.d#dd ddĀe^}/// The 64-bit two's complement integer at `address + sizeOf() * index`. /// /// The [address] must be 8-byte aligned.ea efepf }/// The 64-bit two's complement integer at `address + sizeOf() * index`. /// /// The [address] must be 8-byte aligned.f ff ff)f9/// Pointer arithmetic (takes element size into account).f ffefffpffqfhr/// A pointer to the [offset]th [Int64] after this one. /// /// Returns a pointer to the [Int64] whose address is /// [offset] times the size of `Int64` after the address of this pointer. /// That is `(this + offset).address == this.address + offset * sizeOf()`. /// /// Also `(this + offset).value` is equivalent to `this[offset]`, /// and similarly for setting.h h hxhyh~hhhhhhhiKk /// A pointer to the [offset]th [Int64] before this one. /// /// Equivalent to `this + (-offset)`. /// /// Returns a pointer to the [Int64] whose address is /// [offset] times the size of `Int64` before the address of this pointer. /// That is, `(this - offset).address == this.address - offset * sizeOf()`. /// /// Also, `(this - offset).value` is equivalent to `this[-offset]`, /// and similarly for setting,k k jjjjjjjjjjk`m/// Creates a typed list view backed by memory in the address space. /// /// The returned view will allow access to the memory range from [address] /// to `address + sizeOf() * length`. /// /// The user has to ensure the memory range is accessible while using the /// returned list. /// /// If provided, [finalizer] will be run on the pointer once the typed list /// is GCed. If provided, [token] will be passed to [finalizer], otherwise /// the this pointer itself will be passed. /// /// The [address] must be 8-byte aligned.m mm9mn"n$ mmmmmnnn nn n3nE/// Extension on [Pointer] specialized for the type argument [Uint8].no/// The 8-bit unsigned integer at [address]. /// /// A Dart integer is truncated to 8 bits (as if by `.toUnsigned(8)`) before /// being stored, and the 8-bit value is zero-extended when it is loaded.o#oo oop/// The 8-bit unsigned integer at `address + sizeOf() * index`. /// /// A Dart integer is truncated to 8 bits (as if by `.toUnsigned(8)`) before /// being stored, and the 8-bit value is zero-extended when it is loaded.p ppʁqˀ/// The 8-bit unsigned integer at `address + sizeOf() * index`. /// /// A Dart integer is truncated to 8 bits (as if by `.toUnsigned(8)`) before /// being stored, and the 8-bit value is zero-extended when it is loaded.q qq qqr\9/// Pointer arithmetic (takes element size into account).rf rkr%r&r0rIr1rt~r/// A pointer to the [offset]th [Uint8] after this one. /// /// Returns a pointer to the [Uint8] whose address is /// [offset] times the size of `Uint8` after the address of this pointer. /// That is `(this + offset).address == this.address + offset * sizeOf()`. /// /// Also `(this + offset).value` is equivalent to `this[offset]`, /// and similarly for setting.t t t8t9t>tDt?tHtItOtbtPtтKv́/// A pointer to the [offset]th [Uint8] before this one. /// /// Equivalent to `this + (-offset)`. /// /// Returns a pointer to the [Uint8] whose address is /// [offset] times the size of `Uint8` before the address of this pointer. /// That is, `(this - offset).address == this.address - offset * sizeOf()`. /// /// Also, `(this - offset).value` is equivalent to `this[-offset]`, /// and similarly for setting,v v vvvvvvvvvvw y2/// Creates a typed list view backed by memory in the address space. /// /// The returned view will allow access to the memory range from [address] /// to `address + sizeOf() * length`. /// /// The user has to ensure the memory range is accessible while using the /// returned list. /// /// If provided, [finalizer] will be run on the pointer once the typed list /// is GCed. If provided, [token] will be passed to [finalizer], otherwise /// the this pointer itself will be passed.yC yHyU9yy"y yUyVy[yay\yyyyyyuzF/// Extension on [Pointer] specialized for the type argument [Uint16].z7{N/// The 16-bit unsigned integer at [address]. /// /// A Dart integer is truncated to 16 bits (as if by `.toUnsigned(16)`) before /// being stored, and the 16-bit value is zero-extended when it is loaded. /// /// The [address] must be 2-byte aligned.{X#{j{p {u{E|/// The 16-bit unsigned integer at `address + sizeOf() * index`. /// /// A Dart integer is truncated to 16 bits (as if by `.toUnsigned(16)`) before /// being stored, and the 16-bit value is zero-extended when it is loaded. /// /// The [address] must be 2-byte aligned.| ||ȁR~/// The 16-bit unsigned integer at `address + sizeOf() * index`. /// /// A Dart integer is truncated to 16 bits (as if by `.toUnsigned(16)`) before /// being stored, and the 16-bit value is zero-extended when it is loaded. /// /// The [address] must be 2-byte aligned.~ ~ ~ ~~~9/// Pointer arithmetic (takes element size into account).~ ~~Z~[~e~~~f~v/// A pointer to the [offset]th [Uint16] after this one. /// /// Returns a pointer to the [Uint16] whose address is /// [offset] times the size of `Uint16` after the address of this pointer. /// That is `(this + offset).address == this.address + offset * sizeOf()`. /// /// Also `(this + offset).value` is equivalent to `this[offset]`, /// and similarly for setting. styzQ/// A pointer to the [offset]th [Uint16] before this one. /// /// Equivalent to `this + (-offset)`. /// /// Returns a pointer to the [Uint16] whose address is /// [offset] times the size of `Uint16` before the address of this pointer. /// That is, `(this - offset).address == this.address - offset * sizeOf()`. /// /// Also, `(this - offset).value` is equivalent to `this[-offset]`, /// and similarly for setting,  c/// Creates a typed list view backed by memory in the address space. /// /// The returned view will allow access to the memory range from [address] /// to `address + sizeOf() * length`. /// /// The user has to ensure the memory range is accessible while using the /// returned list. /// /// If provided, [finalizer] will be run on the pointer once the typed list /// is GCed. If provided, [token] will be passed to [finalizer], otherwise /// the this pointer itself will be passed. /// /// The [address] must be 2-byte aligned. 9 ") 8uF/// Extension on [Pointer] specialized for the type argument [Uint32].ŀ/// The 32-bit unsigned integer at [address]. /// /// A Dart integer is truncated to 32 bits (as if by `.toUnsigned(32)`) before /// being stored, and the 32-bit value is zero-extended when it is loaded. /// /// The [address] must be 4-byte aligned.# E-/// The 32-bit unsigned integer at `address + sizeOf() * index`. /// /// A Dart integer is truncated to 32 bits (as if by `.toUnsigned(32)`) before /// being stored, and the 32-bit value is zero-extended when it is loaded. /// /// The [address] must be 4-byte aligned.0 5?Rw/// The 32-bit unsigned integer at `address + sizeOf() * index`. /// /// A Dart integer is truncated to 32 bits (as if by `.toUnsigned(32)`) before /// being stored, and the 32-bit value is zero-extended when it is loaded. /// /// The [address] must be 4-byte aligned.{ 9/// Pointer arithmetic (takes element size into account). c1v/// A pointer to the [offset]th [Uint32] after this one. /// /// Returns a pointer to the [Uint32] whose address is /// [offset] times the size of `Uint32` after the address of this pointer. /// That is `(this + offset).address == this.address + offset * sizeOf()`. /// /// Also `(this + offset).value` is equivalent to `this[offset]`, /// and similarly for setting.3 8 Q/// A pointer to the [offset]th [Uint32] before this one. /// /// Equivalent to `this + (-offset)`. /// /// Returns a pointer to the [Uint32] whose address is /// [offset] times the size of `Uint32` before the address of this pointer. /// That is, `(this - offset).address == this.address - offset * sizeOf()`. /// /// Also, `(this - offset).value` is equivalent to `this[-offset]`, /// and similarly for setting, ?@EKFOPViWڂ /// Creates a typed list view backed by memory in the address space. /// /// The returned view will allow access to the memory range from [address] /// to `address + sizeOf() * length`. /// /// The user has to ensure the memory range is accessible while using the /// returned list. /// /// If provided, [finalizer] will be run on the pointer once the typed list /// is GCed. If provided, [token] will be passed to [finalizer], otherwise /// the this pointer itself will be passed. /// /// The [address] must be 4-byte aligned.1 6C9t" CDIOJF/// Extension on [Pointer] specialized for the type argument [Uint64].%y[/// The 64-bit unsigned integer at [address]. /// /// The [address] must be 8-byte aligned.# ɀ\v/// The 64-bit unsigned integer at `address + sizeOf() * index`. /// /// The [address] must be 8-byte aligned._ dnv/// The 64-bit unsigned integer at `address + sizeOf() * index`. /// /// The [address] must be 8-byte aligned.   9/// Pointer arithmetic (takes element size into account). \]ghv/// A pointer to the [offset]th [Uint64] after this one. /// /// Returns a pointer to the [Uint64] whose address is /// [offset] times the size of `Uint64` after the address of this pointer. /// That is `(this + offset).address == this.address + offset * sizeOf()`. /// /// Also `(this + offset).value` is equivalent to `this[offset]`, /// and similarly for setting. uv{|Q/// A pointer to the [offset]th [Uint64] before this one. /// /// Equivalent to `this + (-offset)`. /// /// Returns a pointer to the [Uint64] whose address is /// [offset] times the size of `Uint64` before the address of this pointer. /// That is, `(this - offset).address == this.address - offset * sizeOf()`. /// /// Also, `(this - offset).value` is equivalent to `this[-offset]`, /// and similarly for setting,  e/// Creates a typed list view backed by memory in the address space. /// /// The returned view will allow access to the memory range from [address] /// to `address + sizeOf() * length`. /// /// The user has to ensure the memory range is accessible while using the /// returned list. /// /// If provided, [finalizer] will be run on the pointer once the typed list /// is GCed. If provided, [token] will be passed to [finalizer], otherwise /// the this pointer itself will be passed. /// /// The [address] must be 8-byte aligned. 9 "+ :E/// Extension on [Pointer] specialized for the type argument [Float]./// The float at [address]. /// /// A Dart double loses precision before being stored, and the float value is /// converted to a double when it is loaded. /// /// The [address] must be 4-byte aligned.& ʁҀ/// The float at `address + sizeOf() * index`. /// /// A Dart double loses precision before being stored, and the float value is /// converted to a double when it is loaded. /// /// The [address] must be 4-byte aligned. #/// The float at `address + sizeOf() * index`. /// /// A Dart double loses precision before being stored, and the float value is /// converted to a double when it is loaded. /// /// The [address] must be 4-byte aligned.  ~9/// Pointer arithmetic (takes element size into account). GHRkSׂr/// A pointer to the [offset]th [Float] after this one. /// /// Returns a pointer to the [Float] whose address is /// [offset] times the size of `Float` after the address of this pointer. /// That is `(this + offset).address == this.address + offset * sizeOf()`. /// /// Also `(this + offset).value` is equivalent to `this[offset]`, /// and similarly for setting. Z[`fajkqrK/// A pointer to the [offset]th [Float] before this one. /// /// Equivalent to `this + (-offset)`. /// /// Returns a pointer to the [Float] whose address is /// [offset] times the size of `Float` before the address of this pointer. /// That is, `(this - offset).address == this.address - offset * sizeOf()`. /// /// Also, `(this - offset).value` is equivalent to `this[-offset]`, /// and similarly for setting, B/// Creates a typed list view backed by memory in the address space. /// /// The returned view will allow access to the memory range from [address] /// to `address + sizeOf() * length`. /// /// The user has to ensure the memory range is accessible while using the /// returned list. /// /// If provided, [finalizer] will be run on the pointer once the typed list /// is GCed. If provided, [token] will be passed to [finalizer], otherwise /// the this pointer itself will be passed. /// /// The [address] must be 4-byte aligned. 9" ciF/// Extension on [Pointer] specialized for the type argument [Double].kJ/// The double at [address]. /// /// The [address] must be 8-byte aligned.& &e/// The double at `address + sizeOf() * index`. /// /// The [address] must be 8-byte aligned. @e/// The double at `address + sizeOf() * index`. /// /// The [address] must be 8-byte aligned.D IO Wa9/// Pointer arithmetic (takes element size into account). /v/// A pointer to the [offset]th [Double] after this one. /// /// Returns a pointer to the [Double] whose address is /// [offset] times the size of `Double` after the address of this pointer. /// That is `(this + offset).address == this.address + offset * sizeOf()`. /// /// Also `(this + offset).value` is equivalent to `this[offset]`, /// and similarly for setting.  QQR/// A pointer to the [offset]th [Double] before this one. /// /// Equivalent to `this + (-offset)`. /// /// Returns a pointer to the [Double] whose address is /// [offset] times the size of `Double` before the address of this pointer. /// That is, `(this - offset).address == this.address - offset * sizeOf()`. /// /// Also, `(this - offset).value` is equivalent to `this[-offset]`, /// and similarly for setting,T Y "5#/// Creates a typed list view backed by memory in the address space. /// /// The returned view will allow access to the memory range from [address] /// to `address + sizeOf() * length`. /// /// The user has to ensure the memory range is accessible while using the /// returned list. /// /// If provided, [finalizer] will be run on the pointer once the typed list /// is GCed. If provided, [token] will be passed to [finalizer], otherwise /// the this pointer itself will be passed. /// /// The [address] must be 8-byte aligned. 9AO"m OPU[V|D/// Extension on [Pointer] specialized for the type argument [Bool].5*/// The bool at [address].4$FL R\[3/// The bool at `address + sizeOf() * index`. h3/// The bool at `address + sizeOf() * index`.  '9/// Pointer arithmetic (takes element size into account). cdnon/// A pointer to the [offset]th [Bool] after this one. /// /// Returns a pointer to the [Bool] whose address is /// [offset] times the size of `Bool` after the address of this pointer. /// That is `(this + offset).address == this.address + offset * sizeOf()`. /// /// Also `(this + offset).value` is equivalent to `this[offset]`, /// and similarly for setting. pqv|wE/// A pointer to the [offset]th [Bool] before this one. /// /// Equivalent to `this + (-offset)`. /// /// Returns a pointer to the [Bool] whose address is /// [offset] times the size of `Bool` before the address of this pointer. /// That is, `(this - offset).address == this.address - offset * sizeOf()`. /// /// Also, `(this - offset).value` is equivalent to `this[-offset]`, /// and similarly for setting,  P;/// Bounds checking indexing methods on [Array]s of [Int8].$ 1  v)>(isLeaf: true) /// external void myFunction(Pointer pointer); /// /// void main() { /// final list = Int8List(10); /// myFunction(list.address); /// } /// ``` /// /// The expression before `.address` is evaluated like the left-hand-side of /// an assignment, to something that gives access to the storage behind the /// expression, which can be used both for reading and writing. The `.address` /// then gives a native pointer to that storage. /// /// The `.address` is evaluated just before calling into native code when /// invoking a leaf [Native] external function. This ensures the Dart garbage /// collector will not move the object that the address points in to.jkpvq *Np/// The memory address of the underlying data. /// /// An expression of the form `expression.address` denoting this `address` /// can only occurr as an entire argument expression in the invocation of /// a leaf [Native] external function. /// /// Example: /// /// ```dart import:typed_data /// @Native)>(isLeaf: true) /// external void myFunction(Pointer pointer); /// /// void main() { /// final list = Int16List(10); /// myFunction(list.address); /// } /// ``` /// /// The expression before `.address` is evaluated like the left-hand-side of /// an assignment, to something that gives access to the storage behind the /// expression, which can be used both for reading and writing. The `.address` /// then gives a native pointer to that storage. /// /// The `.address` is evaluated just before calling into native code when /// invoking a leaf [Native] external function. This ensures the Dart garbage /// collector will not move the object that the address points in to.|̶̕N/// The memory address of the underlying data. /// /// An expression of the form `expression.address` denoting this `address` /// can only occurr as an entire argument expression in the invocation of /// a leaf [Native] external function. /// /// Example: /// /// ```dart import:typed_data /// @Native)>(isLeaf: true) /// external void myFunction(Pointer pointer); /// /// void main() { /// final list = Int32List(10); /// myFunction(list.address); /// } /// ``` /// /// The expression before `.address` is evaluated like the left-hand-side of /// an assignment, to something that gives access to the storage behind the /// expression, which can be used both for reading and writing. The `.address` /// then gives a native pointer to that storage. /// /// The `.address` is evaluated just before calling into native code when /// invoking a leaf [Native] external function. This ensures the Dart garbage /// collector will not move the object that the address points in to.|}̂̈̃!BNՈ/// The memory address of the underlying data. /// /// An expression of the form `expression.address` denoting this `address` /// can only occurr as an entire argument expression in the invocation of /// a leaf [Native] external function. /// /// Example: /// /// ```dart import:typed_data /// @Native)>(isLeaf: true) /// external void myFunction(Pointer pointer); /// /// void main() { /// final list = Int64List(10); /// myFunction(list.address); /// } /// ``` /// /// The expression before `.address` is evaluated like the left-hand-side of /// an assignment, to something that gives access to the storage behind the /// expression, which can be used both for reading and writing. The `.address` /// then gives a native pointer to that storage. /// /// The `.address` is evaluated just before calling into native code when /// invoking a leaf [Native] external function. This ensures the Dart garbage /// collector will not move the object that the address points in to. Քխ΄N/// The memory address of the underlying data. /// /// An expression of the form `expression.address` denoting this `address` /// can only occurr as an entire argument expression in the invocation of /// a leaf [Native] external function. /// /// Example: /// /// ```dart import:typed_data /// @Native)>(isLeaf: true) /// external void myFunction(Pointer pointer); /// /// void main() { /// final list = Uint8List(10); /// myFunction(list.address); /// } /// ``` /// /// The expression before `.address` is evaluated like the left-hand-side of /// an assignment, to something that gives access to the storage behind the /// expression, which can be used both for reading and writing. The `.address` /// then gives a native pointer to that storage. /// /// The `.address` is evaluated just before calling into native code when /// invoking a leaf [Native] external function. This ensures the Dart garbage /// collector will not move the object that the address points in to.ՔՕ՚ՠ՛ 9\Rަ/// The memory address of the underlying data. /// /// An expression of the form `expression.address` denoting this `address` /// can only occurr as an entire argument expression in the invocation of /// a leaf [Native] external function. /// /// Example: /// /// ```dart import:typed_data /// @Native)>(isLeaf: true) /// external void myFunction(Pointer pointer); /// /// void main() { /// final list = Uint16List(10); /// myFunction(list.address); /// } /// ``` /// /// The expression before `.address` is evaluated like the left-hand-side of /// an assignment, to something that gives access to the storage behind the /// expression, which can be used both for reading and writing. The `.address` /// then gives a native pointer to that storage. /// /// The `.address` is evaluated just before calling into native code when /// invoking a leaf [Native] external function. This ensures the Dart garbage /// collector will not move the object that the address points in to. !&,'޲R8/// The memory address of the underlying data. /// /// An expression of the form `expression.address` denoting this `address` /// can only occurr as an entire argument expression in the invocation of /// a leaf [Native] external function. /// /// Example: /// /// ```dart import:typed_data /// @Native)>(isLeaf: true) /// external void myFunction(Pointer pointer); /// /// void main() { /// final list = Uint32List(10); /// myFunction(list.address); /// } /// ``` /// /// The expression before `.address` is evaluated like the left-hand-side of /// an assignment, to something that gives access to the storage behind the /// expression, which can be used both for reading and writing. The `.address` /// then gives a native pointer to that storage. /// /// The `.address` is evaluated just before calling into native code when /// invoking a leaf [Native] external function. This ensures the Dart garbage /// collector will not move the object that the address points in to.޲޳޸޾޹D]〄Rʃ/// The memory address of the underlying data. /// /// An expression of the form `expression.address` denoting this `address` /// can only occurr as an entire argument expression in the invocation of /// a leaf [Native] external function. /// /// Example: /// /// ```dart import:typed_data /// @Native)>(isLeaf: true) /// external void myFunction(Pointer pointer); /// /// void main() { /// final list = Uint64List(10); /// myFunction(list.address); /// } /// ``` /// /// The expression before `.address` is evaluated like the left-hand-side of /// an assignment, to something that gives access to the storage behind the /// expression, which can be used both for reading and writing. The `.address` /// then gives a native pointer to that storage. /// /// The `.address` is evaluated just before calling into native code when /// invoking a leaf [Native] external function. This ensures the Dart garbage /// collector will not move the object that the address points in to.DEJPKքP\/// The memory address of the underlying data. /// /// An expression of the form `expression.address` denoting this `address` /// can only occurr as an entire argument expression in the invocation of /// a leaf [Native] external function. /// /// Example: /// /// ```dart import:typed_data /// @Native)>(isLeaf: true) /// external void myFunction(Pointer pointer); /// /// void main() { /// final list = Float32List(10); /// myFunction(list.address); /// } /// ``` /// /// The expression before `.address` is evaluated like the left-hand-side of /// an assignment, to something that gives access to the storage behind the /// expression, which can be used both for reading and writing. The `.address` /// then gives a native pointer to that storage. /// /// The `.address` is evaluated just before calling into native code when /// invoking a leaf [Native] external function. This ensures the Dart garbage /// collector will not move the object that the address points in to.h즄S/// The memory address of the underlying data. /// /// An expression of the form `expression.address` denoting this `address` /// can only occurr as an entire argument expression in the invocation of /// a leaf [Native] external function. /// /// Example: /// /// ```dart import:typed_data /// @Native)>(isLeaf: true) /// external void myFunction(Pointer pointer); /// /// void main() { /// final list = Float64List(10); /// myFunction(list.address); /// } /// ``` /// /// The expression before `.address` is evaluated like the left-hand-side of /// an assignment, to something that gives access to the storage behind the /// expression, which can be used both for reading and writing. The `.address` /// then gives a native pointer to that storage. /// /// The `.address` is evaluated just before calling into native code when /// invoking a leaf [Native] external function. This ensures the Dart garbage /// collector will not move the object that the address points in to.hintoqG/// Extension on [Pointer] specialized for the type argument [Pointer].c 6/// The pointer at [address]. /// /// A [Pointer] is unboxed before being stored (as if by `.address`), and the /// pointer is boxed (as if by `Pointer.fromAddress`) when loaded. /// /// On 32-bit platforms the [address] must be 4-byte aligned, and on 64-bit /// platforms the [address] must be 8-byte aligned.*)/;EŁT/// Load a Dart value from this location offset by [index]. /// /// A [Pointer] is unboxed before being stored (as if by `.address`), and the /// pointer is boxed (as if by `Pointer.fromAddress`) when loaded. /// /// On 32-bit platforms the [address] must be 4-byte aligned, and on 64-bit /// platforms the [address] must be 8-byte aligned. ׁRU/// Store a Dart value into this location offset by [index]. /// /// A [Pointer] is unboxed before being stored (as if by `.address`), and the /// pointer is boxed (as if by [Pointer.fromAddress]) when loaded. /// /// On 32-bit platforms the [address] must be 4-byte aligned, and on 64-bit /// platforms the [address] must be 8-byte aligned.V [amw9/// Pointer arithmetic (takes element size into account). ΁/// A pointer to the [offset]th [Pointer] after this one. /// /// Returns a pointer to the [Pointer] whose address is /// [offset] times the size of `Pointer` after the address of this pointer. /// That is `(this + offset).address == this.address + offset * sizeOf>()`. /// /// Also `(this + offset).value` is equivalent to `this[offset]`, /// and similarly for setting. Ё/// A pointer to the [offset]th [Pointer] before this one. /// /// Equivalent to `this + (-offset)`. /// /// Returns a pointer to the [Pointer] whose address is /// [offset] times the size of `Pointer` before the address of this pointer. /// That is, `(this - offset).address == this.address - offset * sizeOf>()`. /// /// Also, `(this - offset).value` is equivalent to `this[-offset]`, /// and similarly for setting, ≔CF/// Extension on [Pointer] specialized for the type argument [Struct].PPt'/// A Dart view of the struct referenced by this pointer. /// /// Reading [ref] creates a reference accessing the fields of this struct /// backed by native memory at [address]. /// The [address] must be aligned according to the struct alignment rules of /// the platform. /// /// Assigning to [ref] copies contents of the struct into the native memory /// starting at [address]. /// /// This extension method must be invoked on a receiver of type `Pointer` /// where `T` is a compile-time constant type.?^/// Creates a reference to access the fields of this struct backed by native /// memory at `address + sizeOf() * index`. /// /// The [address] must be aligned according to the struct alignment rules of /// the platform. /// /// This extension method must be invoked on a receiver of type `Pointer` /// where `T` is a compile-time constant type.B GQU/// Copies the [value] struct into native memory, starting at /// `address * sizeOf() * index`. /// /// This extension method must be invoked on a receiver of type `Pointer` /// where `T` is a compile-time constant type.Y ^dgq8/// Pointer arithmetic (takes element size into account) b/// A pointer to the [offset]th [T] after this one. /// /// Returns a pointer to the [T] whose address is /// [offset] times the size of `T` after the address of this pointer. /// That is `(this + offset).address == this.address + offset * sizeOf()`. /// /// Also `(this + offset).value` is equivalent to `this[offset]`, /// and similarly for setting. f/// A pointer to the [offset]th [T] before this one. /// /// Equivalent to `this + (-offset)`. /// /// Returns a pointer to the [T] whose address is /// [offset] times the size of `T` before the address of this pointer. /// That is, `(this - offset).address == this.address - offset * sizeOf()`. /// /// Also, `(this - offset).value` is equivalent to `this[-offset]`, /// and similarly for setting,h m)*/60xE/// Extension on [Pointer] specialized for the type argument [Union].#&/// A Dart view of the union referenced by this pointer. /// /// Reading [ref] creates a reference accessing the fields of this union /// backed by native memory at [address]. /// The [address] must be aligned according to the union alignment rules of /// the platform. /// /// Assigning to [ref] copies contents of the union into the native memory /// starting at [address]. /// /// This extension method must be invoked on a receiver of type `Pointer` /// where `T` is a compile-time constant type.-:>AḰ\/// Creates a reference to access the fields of this union backed by native /// memory at `address + sizeOf() * index`. /// /// The [address] must be aligned according to the union alignment rules of /// the platform. /// /// This extension method must be invoked on a receiver of type `Pointer` /// where `T` is a compile-time constant type. ށ /// Copies the [value] union into native memory, starting at /// `address * sizeOf() * index`. /// /// This extension method must be invoked on a receiver of type `Pointer` /// where `T` is a compile-time constant type.      u9/// Pointer arithmetic (takes element size into account).    9 : D ] E  b/// A pointer to the [offset]th [T] after this one. /// /// Returns a pointer to the [T] whose address is /// [offset] times the size of `T` after the address of this pointer. /// That is `(this + offset).address == this.address + offset * sizeOf()`. /// /// Also `(this + offset).value` is equivalent to `this[offset]`, /// and similarly for setting.  % 0 /// A pointer to the [offset]th [T] before this one. /// /// Equivalent to `this + (-offset)`. /// /// Returns a pointer to the [T] whose address is /// [offset] times the size of `T` before the address of this pointer. /// That is, `(this - offset).address == this.address - offset * sizeOf()`. /// /// Also, `(this - offset).value` is equivalent to `this[-offset]`, /// and similarly for setting,  vV/// Extension on [Pointer] specialized for the type argument /// [AbiSpecificInteger].7/// The integer at [address].# %Zq3/// The integer at `address + sizeOf() * index`.t yg3/// The integer at `address + sizeOf() * index`.  f9/// Pointer arithmetic (takes element size into account).p u*+5N6b/// A pointer to the [offset]th [T] after this one. /// /// Returns a pointer to the [T] whose address is /// [offset] times the size of `T` after the address of this pointer. /// That is `(this + offset).address == this.address + offset * sizeOf()`. /// /// Also `(this + offset).value` is equivalent to `this[offset]`, /// and similarly for setting. !䁑/// A pointer to the [offset]th [T] before this one. /// /// Equivalent to `this + (-offset)`. /// /// Returns a pointer to the [T] whose address is /// [offset] times the size of `T` before the address of this pointer. /// That is, `(this - offset).address == this.address - offset * sizeOf()`. /// /// Also, `(this - offset).value` is equivalent to `this[-offset]`, /// and similarly for setting, \]bicO>/// Bounds checking indexing methods on [Array]s of [Pointer].[[+ 8 56;B<)M=/// Bounds checking indexing methods on [Array]s of [Struct].XXz{/// This extension method must be invoked on a receiver of type `Pointer` /// where `T` is a compile-time constant type. 349@: &w` /// where `T` is a compile-time constant type.9 >]^cjdH)>(isLeaf: true) /// external void myFunction(Pointer pointer); /// /// final class MyStruct extends Struct { /// @Array(10) /// external Array array; /// } /// /// void main() { /// final array = Struct.create().array; /// myFunction(array.address); /// } /// ``` /// /// The expression before `.address` is evaluated like the left-hand-side of /// an assignment, to something that gives access to the storage behind the /// expression, which can be used both for reading and writing. The `.address` /// then gives a native pointer to that storage. /// /// The `.address` is evaluated just before calling into native code when /// invoking a leaf [Native] external function. This ensures the Dart garbage /// collector will not move the object that the address points in to.CDIOJMfss#:U/// The memory address of the underlying data. /// /// An expression of the form `expression.address` denoting this `address` can /// only occurr as an entire argument expression in the invocation of a leaf /// [Native] external function. /// /// Example: /// /// ```dart /// @Native)>(isLeaf: true) /// external void myFunction(Pointer pointer); /// /// final class MyStruct extends Struct { /// @Int8() /// external int x; /// } /// /// void main() { /// final myStruct = Struct.create(); /// myFunction(myStruct.address); /// } /// ``` /// /// The expression before `.address` is evaluated like the left-hand-side of /// an assignment, to something that gives access to the storage behind the /// expression, which can be used both for reading and writing. The `.address` /// then gives a native pointer to that storage. /// /// The `.address` is evaluated just before calling into native code when /// invoking a leaf [Native] external function. This ensures the Dart garbage /// collector will not move the object that the address points in to.MNSYT#F#_#k#k#()M/// The memory address of the underlying data. /// /// An expression of the form `expression.address` denoting this `address` can /// only occurr as an entire argument expression in the invocation of a leaf /// [Native] external function. /// /// Example: /// /// ```dart /// @Native)>(isLeaf: true) /// external void myFunction(Pointer pointer); /// /// final class MyUnion extends Union { /// @Int8() /// external int x; /// } /// /// void main() { /// final myUnion = Union.create(); /// myFunction(myUnion.address); /// } /// ``` /// /// The expression before `.address` is evaluated like the left-hand-side of /// an assignment, to something that gives access to the storage behind the /// expression, which can be used both for reading and writing. The `.address` /// then gives a native pointer to that storage. /// /// The `.address` is evaluated just before calling into native code when /// invoking a leaf [Native] external function. This ensures the Dart garbage /// collector will not move the object that the address points in to.#F#G#L#R#M(5(N(c/#K/// The memory address of the underlying data. /// /// An expression of the form `expression.address` denoting this `address` can /// only occurr as an entire argument expression in the invocation of a leaf /// [Native] external function. /// /// Can only be used on fields of [Struct] subtypes, fields of [Union] /// subtypes, [Array] elements, or [TypedData] elements. In other words, the /// number whose address is being accessed must itself be acccessed through a /// [Struct], [Union], [Array], or [TypedData]. /// /// Example: /// /// ```dart import:typed_data /// @Native)>(isLeaf: true) /// external void myFunction(Pointer pointer); /// /// final class MyStruct extends Struct { /// @Int8() /// external int x; /// /// @Int8() /// external int y; /// /// @Array(10) /// external Array array; /// } /// /// void main() { /// final myStruct = Struct.create(); /// myFunction(myStruct.y.address); /// myFunction(myStruct.array[5].address); /// /// final list = Int8List(10); /// myFunction(list[5].address); /// } /// ``` /// /// The expression before `.address` is evaluated like the left-hand-side of /// an assignment, to something that gives access to the storage behind the /// expression, which can be used both for reading and writing. The `.address` /// then gives a native pointer to that storage. /// /// The `.address` is evaluated just before calling into native code when /// invoking a leaf [Native] external function. This ensures the Dart garbage /// collector will not move the object that the address points in to.(5(6(;(A(<// /H/c61Y/// The memory address of the underlying data. /// /// An expression of the form `expression.address` denoting this `address` can /// only occurr as an entire argument expression in the invocation of a leaf /// [Native] external function. /// /// Can only be used on fields of [Struct] subtypes, fields of [Union] /// subtypes, [Array] elements, or [TypedData] elements. In other words, the /// number whose address is being accessed must itself be acccessed through a /// [Struct], [Union], [Array], or [TypedData]. /// /// Example: /// /// ```dart import:typed_data /// @Native)>(isLeaf: true) /// external void myFunction(Pointer pointer); /// /// final class MyStruct extends Struct { /// @Float() /// external double x; /// /// @Float() /// external double y; /// /// @Array(10) /// external Array array; /// } /// /// void main() { /// final myStruct = Struct.create(); /// myFunction(myStruct.y.address); /// myFunction(myStruct.array[5].address); /// /// final list = Float32List(10); /// myFunction(list[5].address); /// } /// ``` /// /// The expression before `.address` is evaluated like the left-hand-side of /// an assignment, to something that gives access to the storage behind the /// expression, which can be used both for reading and writing. The `.address` /// then gives a native pointer to that storage. /// /// The `.address` is evaluated just before calling into native code when /// invoking a leaf [Native] external function. This ensures the Dart garbage /// collector will not move the object that the address points in to.///0/5/;/66=y6V6mF)>(isLeaf: true) /// external void myFunction(Pointer pointer); /// /// final class MyStruct extends Struct { /// @Bool() /// external bool x; /// /// @Bool() /// external bool y; /// /// @Array(10) /// external Array array; /// } /// /// void main() { /// final myStruct = Struct.create(); /// myFunction(myStruct.y.address); /// myFunction(myStruct.array[5].address); /// } /// ``` /// /// The expression before `.address` is evaluated like the left-hand-side of /// an assignment, to something that gives access to the storage behind the /// expression, which can be used both for reading and writing. The `.address` /// then gives a native pointer to that storage. /// /// The `.address` is evaluated just before calling into native code when /// invoking a leaf [Native] external function. This ensures the Dart garbage /// collector will not move the object that the address points in to.6=6>6C6I6D<,=C/// Extension to retrieve the native `Dart_Port` from a [SendPort].=/>ׁ/// The native port of this [SendPort]. /// /// The returned native port can for example be used by C code to post /// messages to the connected [ReceivePort] via `Dart_PostCObject()` - see /// `dart_native_api.h`. /// /// Only the send ports from the platform classes [ReceivePort] and /// [RawReceivePort] are supported. User-defined implementations of /// [SendPort] are not supported.<<===׃/// Number of bytes used by native type T. /// /// Includes padding and alignment of structs. /// /// This function must be invoked with a compile-time constant [T].?GP?O?y?̀Om/// Represents a pointer into the native C memory corresponding to 'NULL', e.g. /// a pointer with address 0.Y`alnmdart.ffiN׀؁-1y}Ձ2Ki˂߂"QU˃̄:qrӄ6[܆ULÈ]ASωxӊԋ2[}#%&GVόՌ!LRjōˍ,BXĎҎgm DҐؑ$c(.ci•ȕ!'tɗ5NX`jp V\'H\p4Yݛ}ߛ Uxz{ל ";<[\ܝ%:Odyߞ0Kf*/zӡQ¡ 4I^âģQlأI~ ZI9ը!m$&'ko *8rתݫ)v9KQ>oʮ@DE+ek>۲ _-3FLZu>oӵB{ Sжڷ&,zɷ6<]ek#)XԺ7ǺNRSǼBCz˼ۼRbcC.12w׿@*@v@@@@AAA[AAABB%BrBBBC/CWCCCCCD3D~DDEE<ELEjEEEF FF;FAFxFGGGdGGGGHHHcHiHHHI6IKIQIIJJ;JMJJJJJKK.KfKlKLLL:LTLUL{L|LLM#MpMvMMMNN"NqNNNO$O%OaOOOOP+P1PiPQ QQSQtQQQR R RHRNRvR|RSSVS\SSSSTT[T\TTTU%U+UwUUUV-V[VaVVVWW(W.W0W1WwWWWX/X|XXXXXXYBYHYYYZZ=Z>ZZZ[2[8[d[[[[\&\d\e\\\])]}]]]]^^A^^^^^^_(_u__``7`G`e```aaajaaabbbTbbbcc#c5ctcccccddNdTdddddeeeFemeneeef&f'fcffffg-g3gkgh hhUhvhhhiiiJiPixi~ijjXj^jjjjkk]k^kkkl'l-lylllm/m]mcmmmnn*n0n2n3nynnno(otoooooppTpppqqqfqqqr#rKrtrrrrs+swsstt6tFtdtttu uu8u>uvuvvvdvvvvwwwewkwwwx9xNxTxxyy?yQyyyyyzz5zezkz{ {{;{U{V{|{}{{||l|r|||}}}h}}}~~~X~~~~%+d Pq HNv|Y_ `a+1}3ag/5783?E<=,2^!`a(}B,z=Mk%r ] -?~#SYDklZ'-fRs JPx~[a"bc-35ci 179:NTV p EmM7Xh,2Z`:@?@ [pv?Eq^#$^d'^_,-hnIONOF 7c>nt)v Ksy{|12YZ$%a(.e Mn~?EmsJPMOP\k.=d6]^/0dfg9;<zO^#2Y 4^_–˜™ 12gijxà$pęğĮĴEK_łŤŬŶż Yƪ/(Y_Ȭ!'6<\ɗ /7AGʖ5hn˺ Ry{|̴̊8̈́ͭͳ#[auΙλ"pFЖ@qw9?NTtү%GOY_ӮMԀԆ"jՑՓՔբP֜;sy׍ױ:؈ ^ٮ .Zڋڑ*SYhnێ Bdlv|jݝݣ?އޯޱ޲#p߼ \]/5ACDR~Nw}'-Af=cCI  &F#-3!TZ>eghv(tMSgd:f$ioBC"pj9tuNT;A$LR;A)8r,{U :@)NO <no5;o Qr @&Guwx@F %r+HI06  B H     7 _      D     - . e k     g m  B\k"#Y(P|}5V\X^5D3Bx ]l EGH:<=  @BCQc%Qd k =C'JLM[c ' - Y i      !!!!d!""6"<""# #C#E#F#T###$ $Z$|$$$$$%%"%L%\%t%|%%%%%%&&S&&'%'+'w'((2(4(5(C(a((()8)Z)`))*H*z*****+&+,+X+h+++++++++, ,A,i,,,,,,,-M--..%.q./ /,/.///=/a///080Z0`001H1z111112(2.2Z2k22222222333L3t3333344 4[445-535566:6<6=6K6k6667B7d7j788R8a8g8v8|88899-9=9V9\9l9999999::@:o:w:::;$;u;;;>>Z>>>>>? ??F?G????@ @+@e@k@@@@A*A0ApAAAAB B+BFBBBBBCCGCCCCCCDDWDDDDDE7ERESEEEFFFF`FdFFFGGhGGGH0HcHHIEIbIIJ&J*JzJKK2K6KKKL=LLMMnMMMMMNN9N=NRNoNsNNNNO ONOxOOOOP=PyP}PPPQ8QQQRR RTR|RRRRRSSSS'S-SHSSSSSSTT6T7TTTTU)UvUUUUVV@VfVpVvVVVVVWWW!WOWuWWWWWXX@XJXPXXXYYRYkYlYYYZBZZ[&[v[\\_\\]]]P]e]f]w]]]]]]]^C^^^_-_x__````,`f`p`v``aaa+a1aiaoaaaabb!b+b1bub{bbbbcc<cBcPcicoccccd dYddddde.e_eaebeeeef:f~fggNg`gdgghFhJhhhii i$iPiti|iiiiiijjjjGjkjsjwjjjjk0k?kZkkkkkkk abi.dartabi_specific.dartnative_type.dartnative_finalizer.dartallocation.dartannotations.dart c_type.dartdynamic_library.dart struct.dart union.dart;sizeOfnullptrPointerArray _ArraySizeNativeFunctionPointerNativeCallable Int8Pointer Int16Pointer Int32Pointer Int64Pointer Uint8Pointer Uint16Pointer Uint32Pointer Uint64Pointer FloatPointer DoublePointer BoolPointer Int8Array Int16Array Int32Array Int64Array Uint8Array Uint16Array Uint32Array Uint64Array FloatArray DoubleArray BoolArrayInt8ListAddressInt16ListAddressInt32ListAddressInt64ListAddressUint8ListAddressUint16ListAddressUint32ListAddressUint64ListAddressFloat32ListAddressFloat64ListAddressPointerPointer StructPointer UnionPointerAbiSpecificIntegerPointer PointerArray StructArray UnionArray ArrayArrayAbiSpecificIntegerArray ArrayAddress StructAddress UnionAddress IntAddress DoubleAddress BoolAddress NativePort Dart_CObject NativeApiNative DefaultAsset