SYMBOL INDEX (1851 symbols across 168 files)

FILE: bench/index.js
  function median (line 4) | function median(values) {
  function reportBencherDev (line 21) | function reportBencherDev(results) {
  function triple (line 52) | function triple(s, n, b) {

FILE: bench/src/lib.rs
  function export_noop (line 4) | fn export_noop() {}
  function manual_noop (line 6) | fn manual_noop(mut cx: FunctionContext) -> JsResult<JsUndefined> {
  function hello (line 10) | fn hello(mut cx: FunctionContext) -> JsResult<JsString> {
  function call_callback_with_call (line 14) | fn call_callback_with_call(mut cx: FunctionContext) -> JsResult<JsValue> {
  function call_callback_with_call_with (line 24) | fn call_callback_with_call_with(mut cx: FunctionContext) -> JsResult<JsV...
  function call_callback_with_bind (line 34) | fn call_callback_with_bind(mut cx: FunctionContext) -> JsResult<JsValue> {
  function main (line 46) | fn main(mut cx: ModuleContext) -> NeonResult<()> {

FILE: crates/neon-macros/src/class/meta.rs
  type Meta (line 2) | pub(crate) struct Meta {
  type Kind (line 11) | pub(super) enum Kind {
  type PropertyMeta (line 21) | pub(crate) struct PropertyMeta {
  type PropertyParser (line 26) | pub(crate) struct PropertyParser;
    type Output (line 29) | type Output = PropertyMeta;
    method parse2 (line 31) | fn parse2(self, tokens: proc_macro2::TokenStream) -> syn::Result<Self:...
  type Parser (line 63) | pub(crate) struct Parser(pub(crate) Meta);
    type Output (line 66) | type Output = Meta;
    method parse2 (line 68) | fn parse2(self, tokens: proc_macro2::TokenStream) -> syn::Result<Self:...

FILE: crates/neon-macros/src/class/mod.rs
  type ClassItems (line 7) | struct ClassItems {
  function is_receiver_mutable (line 15) | fn is_receiver_mutable(sig: &syn::Signature) -> bool {
  type ParamKind (line 24) | enum ParamKind {
    method from_type (line 31) | fn from_type(ty: &syn::Type) -> Self {
  function extract_param_types (line 51) | fn extract_param_types(sig: &syn::Signature, has_context: bool, has_this...
  function generate_method_wrapper (line 64) | fn generate_method_wrapper(
  function context_parse (line 356) | fn context_parse(
  function check_context (line 381) | fn check_context(opts: &meta::Meta, sig: &syn::Signature) -> syn::Result...
  function check_channel (line 434) | fn check_channel(opts: &meta::Meta, sig: &syn::Signature) -> syn::Result...
  function first_arg (line 471) | fn first_arg<'a>(
  function is_context_type (line 500) | fn is_context_type(ty: &syn::Type) -> bool {
  function is_channel_type (line 509) | fn is_channel_type(ty: &syn::Type) -> bool {
  function type_path_ident (line 519) | fn type_path_ident(ty: &syn::Type) -> Option<&syn::Ident> {
  function validate_method_attributes (line 529) | fn validate_method_attributes(meta: &meta::Meta, sig: &syn::Signature) -...
  function check_this (line 618) | fn check_this(opts: &meta::Meta, sig: &syn::Signature, has_context: bool...
  function check_constructor_context (line 663) | fn check_constructor_context(opts: &meta::Meta, sig: &syn::Signature) ->...
  function generate_constructor_wrapper (line 712) | fn generate_constructor_wrapper(
  function group_class_items (line 775) | fn group_class_items(items: Vec<syn::ImplItem>) -> Result<ClassItems, sy...
  function class (line 821) | pub(crate) fn class(
  function class_with_name (line 828) | pub(crate) fn class_with_name(

FILE: crates/neon-macros/src/export/class.rs
  function export (line 7) | pub(super) fn export(meta: meta::Meta, input: syn::ItemImpl) -> proc_mac...
  function extract_class_ident (line 78) | fn extract_class_ident(input: &syn::ItemImpl) -> syn::Result<syn::Ident> {

FILE: crates/neon-macros/src/export/class/meta.rs
  type Meta (line 5) | pub(crate) struct Meta {
  method parse (line 13) | fn parse(input: ParseStream) -> syn::Result<Self> {
  type Parser (line 87) | pub(crate) struct Parser;
    type Output (line 90) | type Output = Meta;
    method parse2 (line 92) | fn parse2(self, tokens: proc_macro2::TokenStream) -> syn::Result<Self:...

FILE: crates/neon-macros/src/export/function/meta.rs
  type Meta (line 2) | pub(crate) struct Meta {
    method set_name (line 20) | fn set_name(&mut self, meta: syn::meta::ParseNestedMeta) -> syn::Resul...
    method force_json (line 26) | fn force_json(&mut self, _meta: syn::meta::ParseNestedMeta) -> syn::Re...
    method force_context (line 32) | fn force_context(&mut self, _meta: syn::meta::ParseNestedMeta) -> syn:...
    method force_this (line 38) | fn force_this(&mut self, _meta: syn::meta::ParseNestedMeta) -> syn::Re...
    method make_async (line 44) | fn make_async(&mut self, meta: syn::meta::ParseNestedMeta) -> syn::Res...
    method make_task (line 54) | fn make_task(&mut self, _meta: syn::meta::ParseNestedMeta) -> syn::Res...
  type Kind (line 11) | pub(super) enum Kind {
  type Parser (line 61) | pub(crate) struct Parser(syn::ItemFn);
    method new (line 64) | pub(crate) fn new(item: syn::ItemFn) -> Self {
    type Output (line 70) | type Output = (syn::ItemFn, Meta);
    method parse2 (line 72) | fn parse2(self, tokens: proc_macro2::TokenStream) -> syn::Result<Self:...

FILE: crates/neon-macros/src/export/function/mod.rs
  function export (line 7) | pub(super) fn export(meta: meta::Meta, input: syn::ItemFn) -> proc_macro...
  function count_args (line 154) | fn count_args(sig: &syn::Signature, has_context: bool, has_this: bool) -...
  function context_parse (line 165) | fn context_parse(
  function check_context (line 194) | fn check_context(opts: &meta::Meta, sig: &syn::Signature) -> syn::Result...
  function check_channel (line 252) | fn check_channel(opts: &meta::Meta, sig: &syn::Signature) -> syn::Result...
  function first_arg (line 289) | fn first_arg<'a>(
  function is_context_type (line 318) | fn is_context_type(ty: &syn::Type) -> bool {
  function is_channel_type (line 327) | fn is_channel_type(ty: &syn::Type) -> bool {
  function type_path_ident (line 337) | fn type_path_ident(ty: &syn::Type) -> Option<&syn::Ident> {
  function check_this (line 348) | fn check_this(opts: &meta::Meta, sig: &syn::Signature, has_context: bool...

FILE: crates/neon-macros/src/export/global/meta.rs
  type Meta (line 2) | pub(crate) struct Meta {
  type Parser (line 7) | pub(crate) struct Parser;
    type Output (line 10) | type Output = Meta;
    method parse2 (line 12) | fn parse2(self, tokens: proc_macro2::TokenStream) -> syn::Result<Self:...

FILE: crates/neon-macros/src/export/global/mod.rs
  function export (line 4) | pub(super) fn export(meta: meta::Meta, name: &syn::Ident, expr: Box<syn:...

FILE: crates/neon-macros/src/export/mod.rs
  function export (line 7) | pub(crate) fn export(
  function unsupported (line 54) | fn unsupported(item: syn::Item) -> proc_macro::TokenStream {

FILE: crates/neon-macros/src/lib.rs
  function main (line 8) | pub fn main(
  function export (line 40) | pub fn export(
  function class (line 48) | pub fn class(

FILE: crates/neon-macros/src/name.rs
  function to_camel_case (line 8) | pub(crate) fn to_camel_case(name: &str) -> String {
  function is_valid_js_identifier (line 57) | pub(crate) fn is_valid_js_identifier(name: &str) -> bool {
  function to_camel_case (line 130) | fn to_camel_case() {

FILE: crates/neon/src/context/internal.rs
  type Env (line 13) | pub struct Env(raw::Env);
    method from (line 16) | fn from(env: raw::Env) -> Self {
    method to_raw (line 27) | pub(crate) fn to_raw(self) -> raw::Env {
    method try_catch (line 32) | pub(super) unsafe fn try_catch<T, F>(self, f: F) -> Result<T, raw::Local>
  type ContextInternal (line 49) | pub trait ContextInternal<'cx>: Sized {
    method cx (line 50) | fn cx(&self) -> &Cx<'cx>;
    method cx_mut (line 51) | fn cx_mut(&mut self) -> &mut Cx<'cx>;
    method env (line 52) | fn env(&self) -> Env {
  function default_main (line 57) | fn default_main(mut cx: ModuleContext) -> NeonResult<()> {
  function init (line 63) | fn init(cx: ModuleContext) -> NeonResult<()> {
  function napi_register_module_v1 (line 76) | unsafe extern "C" fn napi_register_module_v1(env: *mut c_void, m: *mut c...

FILE: crates/neon/src/context/mod.rs
  type TaskContext (line 205) | pub type TaskContext<'cx> = Cx<'cx>;
  type ExecuteContext (line 209) | pub type ExecuteContext<'cx> = Cx<'cx>;
  type ComputeContext (line 213) | pub type ComputeContext<'cx> = Cx<'cx>;
  type FinalizeContext (line 217) | pub type FinalizeContext<'cx> = Cx<'cx>;
  type SysContext (line 223) | pub type SysContext<'cx> = Cx<'cx>;
  type Cx (line 226) | pub struct Cx<'cx> {
  function from_raw (line 241) | pub unsafe fn from_raw(env: sys::Env) -> Self {
  function new (line 248) | fn new(env: Env) -> Self {
  function with_context (line 255) | pub(crate) fn with_context<T, F: for<'b> FnOnce(Cx<'b>) -> T>(env: Env, ...
  function cx (line 264) | fn cx(&self) -> &Cx<'cx> {
  function cx_mut (line 268) | fn cx_mut(&mut self) -> &mut Cx<'cx> {
  function from (line 276) | fn from(cx: FunctionContext<'cx>) -> Self {
  function from (line 282) | fn from(cx: ModuleContext<'cx>) -> Self {
  type CallbackInfo (line 288) | pub(crate) struct CallbackInfo<'cx> {
  function new (line 294) | pub unsafe fn new(info: raw::FunctionCallbackInfo) -> Self {
  function kind (line 301) | fn kind<'b, C: Context<'b>>(&self, cx: &C) -> CallKind {
  function len (line 309) | pub fn len<'b, C: Context<'b>>(&self, cx: &C) -> usize {
  function argv (line 313) | pub fn argv<'b, C: Context<'b>>(&self, cx: &mut C) -> sys::call::Argumen...
  function this (line 317) | pub fn this<'b, C: Context<'b>>(&self, cx: &mut C) -> raw::Local {
  function argv_exact (line 326) | pub(crate) fn argv_exact<'b, C: Context<'b>, const N: usize>(
  type CallKind (line 357) | pub enum CallKind {
  type Context (line 367) | pub trait Context<'a>: ContextInternal<'a> {
    method lock (line 371) | fn lock<'b>(&'b mut self) -> Lock<'b, Self>
    method execute_scoped (line 383) | fn execute_scoped<'b, T, F>(&mut self, f: F) -> T
    method compute_scoped (line 402) | fn compute_scoped<'b, V, F>(&mut self, f: F) -> JsResult<'a, V>
    method try_catch (line 419) | fn try_catch<T, F>(&mut self, f: F) -> Result<T, Handle<'a, JsValue>>
    method boolean (line 431) | fn boolean(&mut self, b: bool) -> Handle<'a, JsBoolean> {
    method number (line 436) | fn number<T: Into<f64>>(&mut self, x: T) -> Handle<'a, JsNumber> {
    method string (line 443) | fn string<S: AsRef<str>>(&mut self, s: S) -> Handle<'a, JsString> {
    method try_string (line 450) | fn try_string<S: AsRef<str>>(&mut self, s: S) -> StringResult<'a> {
    method null (line 455) | fn null(&mut self) -> Handle<'a, JsNull> {
    method undefined (line 460) | fn undefined(&mut self) -> Handle<'a, JsUndefined> {
    method empty_object (line 465) | fn empty_object(&mut self) -> Handle<'a, JsObject> {
    method empty_array (line 470) | fn empty_array(&mut self) -> Handle<'a, JsArray> {
    method array_buffer (line 475) | fn array_buffer(&mut self, size: usize) -> JsResult<'a, JsArrayBuffer> {
    method buffer (line 480) | fn buffer(&mut self, size: usize) -> JsResult<'a, JsBuffer> {
    method date (line 486) | fn date(&mut self, value: impl Into<f64>) -> Result<Handle<'a, JsDate>...
    method global (line 507) | fn global<T: Value>(&mut self, name: &str) -> JsResult<'a, T> {
    method global_object (line 513) | fn global_object(&mut self) -> Handle<'a, JsObject> {
    method throw (line 520) | fn throw<T: Value, U>(&mut self, v: Handle<T>) -> NeonResult<U> {
    method error (line 528) | fn error<S: AsRef<str>>(&mut self, msg: S) -> JsResult<'a, JsError> {
    method type_error (line 533) | fn type_error<S: AsRef<str>>(&mut self, msg: S) -> JsResult<'a, JsErro...
    method range_error (line 538) | fn range_error<S: AsRef<str>>(&mut self, msg: S) -> JsResult<'a, JsErr...
    method throw_error (line 543) | fn throw_error<S: AsRef<str>, T>(&mut self, msg: S) -> NeonResult<T> {
    method throw_type_error (line 549) | fn throw_type_error<S: AsRef<str>, T>(&mut self, msg: S) -> NeonResult...
    method throw_range_error (line 555) | fn throw_range_error<S: AsRef<str>, T>(&mut self, msg: S) -> NeonResul...
    method boxed (line 576) | fn boxed<U: Finalize + 'static>(&mut self, v: U) -> Handle<'a, JsBox<U...
    method queue (line 583) | fn queue(&mut self) -> Channel {
    method channel (line 593) | fn channel(&mut self) -> Channel {
    method promise (line 617) | fn promise(&mut self) -> (Deferred, Handle<'a, JsPromise>) {
    method task (line 637) | fn task<'cx, O, E>(&'cx mut self, execute: E) -> TaskBuilder<'cx, Self...
    method to_raw (line 649) | fn to_raw(&self) -> sys::Env {
  type ModuleContext (line 655) | pub struct ModuleContext<'cx> {
  type Target (line 661) | type Target = Cx<'cx>;
  method deref (line 663) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 669) | fn deref_mut(&mut self) -> &mut Self::Target {
  function with (line 677) | pub(crate) fn with<T, F: for<'b> FnOnce(ModuleContext<'b>) -> T>(
  function export_function (line 690) | pub fn export_function<T: Value>(
  function export_function (line 702) | pub fn export_function<F, V>(&mut self, key: &str, f: F) -> NeonResult<()>
  function export_value (line 715) | pub fn export_value<T: Value>(&mut self, key: &str, val: Handle<T>) -> N...
  function exports_object (line 721) | pub fn exports_object(&mut self) -> JsResult<'cx, JsObject> {
  function cx (line 727) | fn cx(&self) -> &Cx<'cx> {
  function cx_mut (line 731) | fn cx_mut(&mut self) -> &mut Cx<'cx> {
  type FunctionContext (line 741) | pub struct FunctionContext<'cx> {
  type Target (line 749) | type Target = Cx<'cx>;
  method deref (line 751) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 757) | fn deref_mut(&mut self) -> &mut Self::Target {
  function kind (line 766) | pub fn kind(&self) -> CallKind {
  function with (line 770) | pub(crate) fn with<U, F: for<'b> FnOnce(FunctionContext<'b>) -> U>(
  function len (line 783) | pub fn len(&self) -> usize {
  function is_empty (line 788) | pub fn is_empty(&self) -> bool {
  function argument_opt (line 793) | pub fn argument_opt(&mut self, i: usize) -> Option<Handle<'cx, JsValue>> {
  function argument (line 806) | pub fn argument<V: Value>(&mut self, i: usize) -> JsResult<'cx, V> {
  function this (line 817) | pub fn this<T: Value>(&mut self) -> JsResult<'cx, T> {
  function this_value (line 822) | pub fn this_value(&mut self) -> Handle<'cx, JsValue> {
  function args (line 840) | pub fn args<T>(&mut self) -> NeonResult<T>
  function arg (line 848) | pub fn arg<T>(&mut self) -> NeonResult<T>
  function args_opt (line 872) | pub fn args_opt<T>(&mut self) -> NeonResult<Option<T>>
  function arg_opt (line 880) | pub fn arg_opt<T>(&mut self) -> NeonResult<Option<T>>
  function argv (line 887) | pub(crate) fn argv<const N: usize>(&mut self) -> [Handle<'cx, JsValue>; ...
  function cx (line 893) | fn cx(&self) -> &Cx<'cx> {
  function cx_mut (line 897) | fn cx_mut(&mut self) -> &mut Cx<'cx> {

FILE: crates/neon/src/event/channel.rs
  type Receiver (line 32) | pub(super) struct Receiver<T>(mpsc::Receiver<T>);
  function blocking_recv (line 35) | pub(super) fn blocking_recv(self) -> Result<T, mpsc::RecvError> {
  function channel (line 40) | pub(super) fn channel<T>() -> (mpsc::SyncSender<T>, Receiver<T>) {
  type Callback (line 47) | type Callback = Box<dyn FnOnce(sys::Env) + Send + 'static>;
  type Channel (line 92) | pub struct Channel {
    method fmt (line 98) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method new (line 106) | pub fn new<'a, C: Context<'a>>(cx: &mut C) -> Self {
    method unref (line 115) | pub fn unref<'a, C: Context<'a>>(&mut self, cx: &mut C) -> &mut Self {
    method reference (line 128) | pub fn reference<'a, C: Context<'a>>(&mut self, cx: &mut C) -> &mut Se...
    method send (line 141) | pub fn send<T, F>(&self, f: F) -> JoinHandle<T>
    method try_send (line 153) | pub fn try_send<T, F>(&self, f: F) -> Result<JoinHandle<T>, SendError>
    method has_ref (line 180) | pub fn has_ref(&self) -> bool {
  method clone (line 195) | fn clone(&self) -> Self {
  method drop (line 217) | fn drop(&mut self) {
  type JoinHandle (line 252) | pub struct JoinHandle<T> {
  function join (line 265) | pub fn join(self) -> Result<T, JoinError> {
  type Output (line 273) | type Output = Result<T, JoinError>;
  method poll (line 275) | fn poll(mut self: Pin<&mut Self>, cx: &mut task::Context) -> Poll<Self::...
  type JoinError (line 294) | pub struct JoinError(JoinErrorType);
    method as_str (line 303) | fn as_str(&self) -> &str {
    method fmt (line 312) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method from (line 320) | fn from(_: oneshot::error::RecvError) -> Self {
    method from (line 329) | fn from(_: SendThrow) -> Self {
  type JoinErrorType (line 297) | enum JoinErrorType {
  type SendThrow (line 326) | pub(crate) struct SendThrow(());
    method from (line 335) | fn from(_: Throw) -> SendThrow {
  function or_throw (line 341) | fn or_throw<'a, C: Context<'a>>(self, cx: &mut C) -> NeonResult<T> {
  type SendError (line 355) | pub struct SendError;
    method fmt (line 358) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method fmt (line 364) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  type ChannelState (line 371) | struct ChannelState {
    method new (line 377) | fn new<'a, C: Context<'a>>(cx: &mut C) -> Self {
    method reference (line 385) | fn reference<'a, C: Context<'a>>(&self, cx: &mut C) {
    method unref (line 397) | fn unref<'a, C: Context<'a>>(&self, cx: &mut C) {
    method callback (line 410) | fn callback(env: Option<sys::Env>, callback: Callback) {

FILE: crates/neon/src/event/mod.rs
  type EventQueue (line 137) | pub type EventQueue = self::channel::Channel;
  type EventQueueError (line 142) | pub type EventQueueError = self::channel::SendError;

FILE: crates/neon/src/event/task.rs
  type TaskBuilder (line 25) | pub struct TaskBuilder<'cx, C, E> {
  function new (line 38) | pub fn new(cx: &'cx mut C, execute: E) -> Self {
  function and_then (line 45) | pub fn and_then<F>(self, complete: F)
  function promise (line 61) | pub fn promise<V, F>(self, complete: F) -> Handle<'a, JsPromise>
  function schedule (line 77) | fn schedule<I, O, D>(env: Env, input: I, data: D)
  function execute (line 88) | fn execute<I, O>(input: I) -> O
  function complete (line 96) | fn complete<O, D>(env: raw::Env, output: thread::Result<O>, callback: D)
  function schedule_promise (line 113) | fn schedule_promise<I, O, D, V>(env: Env, input: I, complete: D, deferre...
  function complete_promise (line 131) | fn complete_promise<O, D, V>(

FILE: crates/neon/src/executor/mod.rs
  type BoxFuture (line 8) | type BoxFuture = Pin<Box<dyn Future<Output = ()> + Send + 'static>>;
  type Runtime (line 12) | pub trait Runtime: Send + Sync + 'static {
    method spawn (line 13) | fn spawn(&self, fut: BoxFuture);
  function set_global_executor (line 50) | pub fn set_global_executor<R>(cx: &mut Cx, runtime: R) -> Result<(), R>

FILE: crates/neon/src/executor/tokio.rs
  method spawn (line 6) | fn spawn(&self, fut: BoxFuture) {
  method spawn (line 12) | fn spawn(&self, fut: BoxFuture) {
  method spawn (line 18) | fn spawn(&self, fut: BoxFuture) {
  method spawn (line 24) | fn spawn(&self, fut: BoxFuture) {
  method spawn (line 30) | fn spawn(&self, fut: BoxFuture) {
  function spawn (line 35) | fn spawn(handle: &tokio::runtime::Handle, fut: BoxFuture) {
  function init (line 41) | pub(crate) fn init(cx: &mut crate::context::ModuleContext) -> crate::res...

FILE: crates/neon/src/handle/internal.rs
  type SuperType (line 5) | pub trait SuperType<T: Value> {
    method upcast_internal (line 6) | fn upcast_internal(v: &T) -> Self;
  type TransparentNoCopyWrapper (line 15) | pub unsafe trait TransparentNoCopyWrapper: Sized {
    method into_inner (line 20) | fn into_inner(self) -> Self::Inner;
    method wrap_ref (line 22) | fn wrap_ref(s: &Self::Inner) -> &Self {
    method wrap_mut (line 26) | fn wrap_mut(s: &mut Self::Inner) -> &mut Self {

FILE: crates/neon/src/handle/mod.rs
  type Handle (line 70) | pub struct Handle<'a, V: Value + 'a> {
  method clone (line 78) | fn clone(&self) -> Self {
  function new_internal (line 86) | pub(crate) fn new_internal(value: V) -> Handle<'a, V> {
  type DowncastError (line 96) | pub struct DowncastError<F: Value, T: Value> {
  method fmt (line 102) | fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
  function new (line 108) | fn new() -> Self {
  method fmt (line 117) | fn fmt(&self, f: &mut fmt::Formatter) -> Result<(), fmt::Error> {
  type DowncastResult (line 125) | pub type DowncastResult<'a, F, T> = Result<Handle<'a, T>, DowncastError<...
  function or_throw (line 128) | fn or_throw<'b, C: Context<'b>>(self, cx: &mut C) -> JsResult<'a, T> {
  function upcast (line 140) | pub fn upcast<U: Value + SuperType<T>>(&self) -> Handle<'a, U> {
  function is_a (line 158) | pub fn is_a<'b, U: Value, C: Context<'b>>(&self, cx: &mut C) -> bool {
  function downcast (line 166) | pub fn downcast<'b, U: Value, C: Context<'b>>(&self, cx: &mut C) -> Down...
  function downcast_or_throw (line 176) | pub fn downcast_or_throw<'b, U: Value, C: Context<'b>>(&self, cx: &mut C...
  function strict_equals (line 180) | pub fn strict_equals<'b, U: Value, C: Context<'b>>(
  type Target (line 190) | type Target = V;
  method deref (line 191) | fn deref(&self) -> &V {
  method deref_mut (line 197) | fn deref_mut(&mut self) -> &mut V {

FILE: crates/neon/src/handle/root.rs
  type InstanceId (line 24) | type InstanceId = ThreadId;
  type NapiRef (line 28) | pub(crate) struct NapiRef(*mut c_void);
    method unref (line 33) | pub(crate) unsafe fn unref(self, env: raw::Env) {
  type Root (line 52) | pub struct Root<T> {
  function fmt (line 63) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function instance_id (line 76) | fn instance_id<'a, C: Context<'a>>(cx: &mut C) -> InstanceId {
  function instance_id (line 81) | fn instance_id<'a, C: Context<'a>>(_: &mut C) -> InstanceId {
  function new (line 95) | pub fn new<'a, C: Context<'a>>(cx: &mut C, value: &T) -> Self {
  function clone (line 120) | pub fn clone<'a, C: Context<'a>>(&self, cx: &mut C) -> Self {
  function drop (line 139) | pub fn drop<'a, C: Context<'a>>(self, cx: &mut C) {
  function into_inner (line 153) | pub fn into_inner<'a, C: Context<'a>>(self, cx: &mut C) -> Handle<'a, T> {
  function to_inner (line 173) | pub fn to_inner<'a, C: Context<'a>>(&self, cx: &mut C) -> Handle<'a, T> {
  function as_napi_ref (line 180) | fn as_napi_ref<'a, C: Context<'a>>(&self, cx: &mut C) -> &NapiRef {
  function into_napi_ref (line 192) | fn into_napi_ref<'a, C: Context<'a>>(mut self, cx: &mut C) -> NapiRef {
  method finalize (line 203) | fn finalize<'a, C: Context<'a>>(self, cx: &mut C) {
  method drop (line 210) | fn drop(&mut self) {
  method drop (line 230) | fn drop(&mut self) {

FILE: crates/neon/src/lib.rs
  type Exports (line 147) | pub struct Exports(());
    method export (line 180) | pub fn export(self, cx: &mut ModuleContext) -> NeonResult<()> {
  type Item (line 192) | type Item = <<Self as IntoIterator>::IntoIter as IntoIterator>::Item;
  type IntoIter (line 193) | type IntoIter = std::slice::Iter<
  method into_iter (line 198) | fn into_iter(self) -> Self::IntoIter {
  function registered (line 204) | pub fn registered() -> Exports {
  function feature_matrix (line 209) | fn feature_matrix() {

FILE: crates/neon/src/lifecycle.rs
  type InstanceId (line 34) | pub(crate) struct InstanceId(u32);
    method next (line 37) | fn next() -> Self {
  type InstanceData (line 51) | pub(crate) struct InstanceData {
    method get (line 243) | pub(crate) fn get<'cx, C: Context<'cx>>(cx: &mut C) -> &mut InstanceDa...
    method drop_queue (line 274) | pub(crate) fn drop_queue<'cx, C: Context<'cx>>(
    method channel (line 282) | pub(crate) fn channel<'cx, C: Context<'cx>>(cx: &mut C) -> Channel {
    method id (line 289) | pub(crate) fn id<'cx, C: Context<'cx>>(cx: &mut C) -> InstanceId {
    method locals (line 294) | pub(crate) fn locals<'cx, C: Context<'cx>>(cx: &mut C) -> &mut LocalTa...
  type LocalTable (line 71) | pub(crate) struct LocalTable {
    method get (line 153) | pub(crate) fn get(&mut self, index: usize) -> &mut LocalCell {
  type LocalCellValue (line 75) | pub(crate) type LocalCellValue = Box<dyn Any + Send + 'static>;
  type LocalCell (line 78) | pub(crate) enum LocalCell {
    method pre_init (line 92) | fn pre_init<F>(&mut self, f: F)
    method get (line 105) | pub(crate) fn get<'cx, 'a, C>(cx: &'a mut C, id: usize) -> Option<&'a ...
    method get_or_init (line 116) | pub(crate) fn get_or_init<'cx, 'a, C, F>(
    method get_or_try_init (line 132) | pub(crate) fn get_or_try_init<'cx, 'a, C, E, F>(
  type TryInitTransaction (line 168) | struct TryInitTransaction<'cx, 'a, C: Context<'cx>> {
  function new (line 175) | fn new(cx: &'a mut C, id: usize) -> Self {
  function run (line 187) | fn run<E, F>(&mut self, f: F) -> Result<(), E>
  function cell (line 198) | fn cell(&mut self) -> &mut LocalCell {
  function is_trying (line 203) | fn is_trying(&mut self) -> bool {
  method drop (line 209) | fn drop(&mut self) {
  type DropData (line 217) | pub(crate) enum DropData {
    method drop (line 224) | fn drop(env: Option<Env>, data: Self) {

FILE: crates/neon/src/macro_internal/futures.rs
  function spawn (line 9) | pub fn spawn<'cx, F, S>(cx: &mut Cx<'cx>, fut: F, settle: S) -> JsResult...

FILE: crates/neon/src/macro_internal/mod.rs
  type Export (line 27) | type Export<'cx> = (&'static str, Handle<'cx, JsValue>);
  type NeonMarker (line 36) | pub struct NeonMarker<Tag, Return>(PhantomData<Tag>, PhantomData<Return>);
  type NeonJsonTag (line 40) | pub struct NeonJsonTag;
  type NeonValueTag (line 41) | pub struct NeonValueTag;
  type NeonResultTag (line 42) | pub struct NeonResultTag;
  type ToNeonMarker (line 44) | pub trait ToNeonMarker {
    method to_neon_marker (line 47) | fn to_neon_marker<Tag>(&self) -> NeonMarker<Tag, Self::Return>;
    type Return (line 52) | type Return = NeonResultTag;
    method to_neon_marker (line 54) | fn to_neon_marker<Tag>(&self) -> NeonMarker<Tag, Self::Return> {
    type Return (line 61) | type Return = NeonValueTag;
    method to_neon_marker (line 63) | fn to_neon_marker<Tag>(&self) -> NeonMarker<Tag, Self::Return> {
  function neon_into_js (line 69) | pub fn neon_into_js<'cx, T>(self, cx: &mut Cx<'cx>, v: T) -> JsResult<'c...
  function neon_into_js (line 79) | pub fn neon_into_js<'cx, T>(self, cx: &mut Cx<'cx>, v: T) -> JsResult<'c...
  function neon_into_js (line 89) | pub fn neon_into_js<'cx, T, E>(
  function into_neon_result (line 102) | pub fn into_neon_result<T>(self, _cx: &mut Cx, v: T) -> NeonResult<T> {
  function into_neon_result (line 108) | pub fn into_neon_result<'cx, T, E>(self, cx: &mut Cx<'cx>, res: Result<T...
  function internal_constructor (line 135) | pub fn internal_constructor<'cx, T: crate::object::Class>(

FILE: crates/neon/src/meta.rs
  constant VERSION (line 6) | pub const VERSION: &str = env!("CARGO_PKG_VERSION");
  constant MAJOR (line 9) | pub const MAJOR: &str = env!("CARGO_PKG_VERSION_MAJOR");
  constant MINOR (line 12) | pub const MINOR: &str = env!("CARGO_PKG_VERSION_MINOR");
  constant PATCH (line 15) | pub const PATCH: &str = env!("CARGO_PKG_VERSION_PATCH");
  function version (line 18) | pub fn version() -> Version {

FILE: crates/neon/src/object/class.rs
  type ClassInternal (line 10) | pub trait ClassInternal {
    method local (line 11) | fn local<'cx>(cx: &mut Cx<'cx>) -> NeonResult<ClassMetadata<'cx>>;
    method create (line 12) | fn create<'cx>(cx: &mut Cx<'cx>) -> NeonResult<ClassMetadata<'cx>>;
  type Class (line 19) | pub trait Class: ClassInternal {
    method name (line 21) | fn name() -> String;
    method constructor (line 24) | fn constructor<'cx>(cx: &mut Cx<'cx>) -> JsResult<'cx, JsFunction>;
  type ClassMetadata (line 28) | pub struct ClassMetadata<'cx> {
  function new_class_metadata (line 33) | pub fn new_class_metadata<'cx>(
  function constructor (line 44) | pub fn constructor(&self) -> Handle<'cx, JsFunction> {
  function internal_constructor (line 48) | pub(crate) fn internal_constructor(&self) -> Handle<'cx, JsFunction> {
  function root (line 53) | pub fn root<'cx2>(&self, cx: &mut Cx<'cx2>) -> RootClassMetadata {
  type RootClassMetadata (line 62) | pub struct RootClassMetadata {
    method to_inner (line 71) | pub fn to_inner<'a, 'cx: 'a>(&'a self, cx: &'a mut Cx<'cx>) -> ClassMe...

FILE: crates/neon/src/object/mod.rs
  type PropertyKey (line 65) | pub trait PropertyKey: Copy {
    method get_from (line 66) | unsafe fn get_from<'c, C: Context<'c>>(
    method set_from (line 73) | unsafe fn set_from<'c, C: Context<'c>>(
    method get_from (line 83) | unsafe fn get_from<'c, C: Context<'c>>(
    method set_from (line 92) | unsafe fn set_from<'c, C: Context<'c>>(
    method get_from (line 104) | unsafe fn get_from<'c, C: Context<'c>>(
    method set_from (line 115) | unsafe fn set_from<'c, C: Context<'c>>(
    method get_from (line 129) | unsafe fn get_from<'c, C: Context<'c>>(
    method set_from (line 141) | unsafe fn set_from<'c, C: Context<'c>>(
  type PropOptions (line 174) | pub struct PropOptions<'a, 'cx, O, K>
  function this (line 192) | pub fn this(&self) -> Handle<'cx, O> {
  function prop (line 214) | pub fn prop(&mut self, key: K) -> &mut Self {
  function get (line 223) | pub fn get<R: TryFromJs<'cx>>(&mut self) -> NeonResult<R> {
  function set (line 231) | pub fn set<V: TryIntoJs<'cx>>(&mut self, v: V) -> NeonResult<&mut Self> {
  function set_with (line 240) | pub fn set_with<R, F>(&mut self, f: F) -> NeonResult<&mut Self>
  function bind (line 255) | pub fn bind(&'a mut self) -> NeonResult<BindOptions<'a, 'cx>> {
  type Object (line 268) | pub trait Object: Value {
    method prop (line 278) | fn prop<'a, 'cx: 'a, K: PropertyKey>(
    method method (line 293) | fn method<'a, 'cx: 'a, K: PropertyKey>(
    method get_opt (line 309) | fn get_opt<'a, V: Value, C: Context<'a>, K: PropertyKey>(
    method get_value (line 324) | fn get_value<'a, C: Context<'a>, K: PropertyKey>(
    method get (line 335) | fn get<'a, V: Value, C: Context<'a>, K: PropertyKey>(
    method get_own_property_names (line 345) | fn get_own_property_names<'a, C: Context<'a>>(&self, cx: &mut C) -> Js...
    method freeze (line 354) | fn freeze<'a, C: Context<'a>>(&self, cx: &mut C) -> NeonResult<&Self> {
    method seal (line 367) | fn seal<'a, C: Context<'a>>(&self, cx: &mut C) -> NeonResult<&Self> {
    method set (line 380) | fn set<'a, C: Context<'a>, K: PropertyKey, W: Value>(
    method root (line 396) | fn root<'a, C: Context<'a>>(&self, cx: &mut C) -> Root<Self> {
    method call_method_with (line 401) | fn call_method_with<'a, C, K>(&self, cx: &mut C, method: K) -> NeonRes...

FILE: crates/neon/src/object/wrap.rs
  type BoxAny (line 15) | type BoxAny = Box<dyn Any + 'static>;
  type WrapError (line 18) | pub struct WrapError(WrapErrorType);
    method object_expected (line 21) | fn object_expected() -> Self {
    method already_wrapped (line 25) | fn already_wrapped() -> Self {
    method not_wrapped (line 30) | fn not_wrapped() -> Self {
    method wrong_type (line 34) | fn wrong_type(expected: &'static str) -> Self {
    method foreign_type (line 39) | fn foreign_type() -> Self {
    method fmt (line 45) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    type Value (line 55) | type Value = crate::types::JsError;
    method try_into_js (line 57) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
  function or_throw (line 66) | fn or_throw<'cx, C>(self, cx: &mut C) -> NeonResult<T>
  type WrapErrorType (line 79) | enum WrapErrorType {
    method fmt (line 100) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function ref_cell_target_type_name (line 89) | fn ref_cell_target_type_name(s: &str) -> Option<String> {
  function wrap (line 117) | pub fn wrap<T, V>(cx: &mut Cx, o: Handle<V>, v: T) -> NeonResult<Result<...
  function unwrap (line 187) | pub fn unwrap<'cx, T, V>(cx: &mut Cx, o: Handle<'cx, V>) -> NeonResult<R...

FILE: crates/neon/src/reflect.rs
  function eval (line 10) | pub fn eval<'a, 'b, C: Context<'a>>(

FILE: crates/neon/src/result/mod.rs
  type Throw (line 51) | pub struct Throw(PhantomData<*mut ()>);
    method new (line 63) | pub unsafe fn new() -> Self {
    method new (line 68) | pub(crate) unsafe fn new() -> Self {
  method fmt (line 74) | fn fmt(&self, fmt: &mut Formatter) -> FmtResult {
  type NeonResult (line 80) | pub type NeonResult<T> = Result<T, Throw>;
  type JsResult (line 83) | pub type JsResult<'b, T> = NeonResult<Handle<'b, T>>;
  type ResultExt (line 87) | pub trait ResultExt<T> {
    method or_throw (line 88) | fn or_throw<'a, C: Context<'a>>(self, cx: &mut C) -> NeonResult<T>;
  function or_throw (line 96) | fn or_throw<'cx, C: Context<'cx>>(self, cx: &mut C) -> JsResult<'a, T> {

FILE: crates/neon/src/sys/array.rs
  function new (line 8) | pub unsafe fn new(out: &mut Local, env: Env, length: usize) {
  function len (line 17) | pub unsafe fn len(env: Env, array: Local) -> u32 {

FILE: crates/neon/src/sys/arraybuffer.rs
  function new (line 10) | pub unsafe fn new(env: Env, len: usize) -> Result<Local, napi::Status> {
  function new_external (line 23) | pub unsafe fn new_external<T>(env: Env, data: T) -> Local
  function drop_external (line 47) | unsafe extern "C" fn drop_external<T>(_env: Env, _data: *mut c_void, hin...
  function as_mut_slice (line 54) | pub unsafe fn as_mut_slice<'a>(env: Env, buf: Local) -> &'a mut [u8] {
  function size (line 69) | pub unsafe fn size(env: Env, buf: Local) -> usize {

FILE: crates/neon/src/sys/async_work.rs
  constant BOUNDARY (line 21) | const BOUNDARY: FailureBoundary = FailureBoundary {
  type Execute (line 27) | type Execute<I, O> = fn(input: I) -> O;
  type Complete (line 28) | type Complete<O, D> = fn(env: Env, output: thread::Result<O>, data: D);
  function schedule (line 36) | pub unsafe fn schedule<I, O, D>(
  type Data (line 84) | struct Data<I, O, D> {
  type State (line 93) | enum State<I, O> {
  function take_execute_input (line 104) | fn take_execute_input(&mut self) -> Option<I> {
  function into_output (line 112) | fn into_output(self) -> Option<thread::Result<O>> {
  function call_execute (line 125) | unsafe extern "C" fn call_execute<I, O, D>(_: Env, data: *mut c_void) {
  function call_complete (line 144) | unsafe extern "C" fn call_complete<I, O, D>(env: Env, status: napi::Stat...

FILE: crates/neon/src/sys/bindings/functions.rs
  function get_version (line 441) | unsafe fn get_version(host: &libloading::Library, env: Env) -> Result<u3...
  function load (line 450) | pub(crate) unsafe fn load(env: Env) -> Result<(), libloading::Error> {

FILE: crates/neon/src/sys/bindings/types.rs
  type Env__ (line 6) | pub struct Env__ {
  type Env (line 12) | pub type Env = *mut Env__;
  type Value__ (line 17) | pub struct Value__ {
  type Value (line 23) | pub type Value = *mut Value__;
  type CallbackInfo__ (line 28) | pub struct CallbackInfo__ {
  type CallbackInfo (line 34) | pub type CallbackInfo = *mut CallbackInfo__;
  type EscapableHandleScope__ (line 39) | pub struct EscapableHandleScope__ {
  type EscapableHandleScope (line 45) | pub type EscapableHandleScope = *mut EscapableHandleScope__;
  type HandleScope__ (line 50) | pub struct HandleScope__ {
  type HandleScope (line 56) | pub type HandleScope = *mut HandleScope__;
  type Ref__ (line 61) | pub struct Ref__ {
  type Ref (line 67) | pub type Ref = *mut Ref__;
  type ThreadsafeFunction__ (line 73) | pub struct ThreadsafeFunction__ {
  type ThreadsafeFunction (line 80) | pub type ThreadsafeFunction = *mut ThreadsafeFunction__;
  type Callback (line 84) | pub type Callback = Option<unsafe extern "C" fn(env: Env, info: Callback...
  type Finalize (line 88) | pub type Finalize =
  type ThreadsafeFunctionCallJs (line 94) | pub type ThreadsafeFunctionCallJs = Option<
  type Status (line 103) | pub enum Status {
  type ValueType (line 133) | pub enum ValueType {
  type TypedArrayType (line 151) | pub enum TypedArrayType {
  type KeyCollectionMode (line 171) | pub enum KeyCollectionMode {
  type KeyConversion (line 182) | pub enum KeyConversion {
  type ThreadsafeFunctionCallMode (line 193) | pub enum ThreadsafeFunctionCallMode {
  type ThreadsafeFunctionReleaseMode (line 204) | pub enum ThreadsafeFunctionReleaseMode {
  type KeyFilter (line 214) | pub struct KeyFilter(pub ::std::os::raw::c_uint);
    constant ALL_PROPERTIES (line 219) | pub const ALL_PROPERTIES: KeyFilter = KeyFilter(0);
    constant WRITABLE (line 220) | pub const WRITABLE: KeyFilter = KeyFilter(1);
    constant CONFIGURABLE (line 221) | pub const CONFIGURABLE: KeyFilter = KeyFilter(4);
    constant SKIP_STRINGS (line 222) | pub const SKIP_STRINGS: KeyFilter = KeyFilter(8);
    constant SKIP_SYMBOLS (line 223) | pub const SKIP_SYMBOLS: KeyFilter = KeyFilter(16);
    type Output (line 228) | type Output = Self;
    method bitor (line 230) | fn bitor(self, other: Self) -> Self {
    method bitor_assign (line 238) | fn bitor_assign(&mut self, rhs: KeyFilter) {
    type Output (line 245) | type Output = Self;
    method bitand (line 247) | fn bitand(self, other: Self) -> Self {
    method bitand_assign (line 255) | fn bitand_assign(&mut self, rhs: KeyFilter) {
  type AsyncWork__ (line 263) | pub struct AsyncWork__ {
  type AsyncWork (line 269) | pub type AsyncWork = *mut AsyncWork__;
  type AsyncExecuteCallback (line 273) | pub type AsyncExecuteCallback = Option<unsafe extern "C" fn(env: Env, da...
  type AsyncCompleteCallback (line 277) | pub type AsyncCompleteCallback =
  type Deferred__ (line 283) | pub struct Deferred__ {
  type Deferred (line 289) | pub type Deferred = *mut Deferred__;
  type TypeTag (line 296) | pub struct TypeTag {

FILE: crates/neon/src/sys/buffer.rs
  function new (line 10) | pub unsafe fn new(env: Env, len: usize) -> Result<Local, napi::Status> {
  function uninitialized (line 18) | pub unsafe fn uninitialized(env: Env, len: usize) -> Result<(Local, *mut...
  function new_external (line 32) | pub unsafe fn new_external<T>(env: Env, data: T) -> Local
  function drop_external (line 56) | unsafe extern "C" fn drop_external<T>(_env: Env, _data: *mut c_void, hin...
  function as_mut_slice (line 63) | pub unsafe fn as_mut_slice<'a>(env: Env, buf: Local) -> &'a mut [u8] {
  function size (line 78) | pub unsafe fn size(env: Env, buf: Local) -> usize {

FILE: crates/neon/src/sys/call.rs
  constant ARGV_SIZE (line 17) | const ARGV_SIZE: usize = 4;
  type Arguments (line 23) | pub struct Arguments(SmallVec<[Local; ARGV_SIZE]>);
    method get (line 28) | pub fn get(&self, i: usize) -> Option<Local> {
  function is_construct (line 33) | pub unsafe fn is_construct(env: Env, info: FunctionCallbackInfo) -> bool {
  function this (line 47) | pub unsafe fn this(env: Env, info: FunctionCallbackInfo, out: &mut Local) {
  function len (line 53) | pub unsafe fn len(env: Env, info: FunctionCallbackInfo) -> usize {
  function argv (line 68) | pub unsafe fn argv(env: Env, info: FunctionCallbackInfo) -> Arguments {

FILE: crates/neon/src/sys/convert.rs
  function to_string (line 6) | pub unsafe fn to_string(out: &mut Local, env: Env, value: Local) -> bool {

FILE: crates/neon/src/sys/date.rs
  function new_date (line 13) | pub unsafe fn new_date(env: Env, value: f64) -> Local {
  function value (line 25) | pub unsafe fn value(env: Env, p: Local) -> f64 {

FILE: crates/neon/src/sys/debug_send_wrapper.rs
  type DebugSendWrapper (line 11) | pub struct DebugSendWrapper<T>(send_wrapper::SendWrapper<T>);
  function new (line 14) | pub fn new(value: T) -> Self {
  function take (line 18) | pub fn take(self) -> T {
  type Target (line 24) | type Target = T;
  method deref (line 26) | fn deref(&self) -> &Self::Target {
  type DebugSendWrapper (line 37) | pub struct DebugSendWrapper<T>(T);
  function new (line 40) | pub fn new(value: T) -> Self {
  function take (line 44) | pub fn take(self) -> T {
  type Target (line 50) | type Target = T;
  method deref (line 52) | fn deref(&self) -> &Self::Target {

FILE: crates/neon/src/sys/error.rs
  function is_throwing (line 8) | pub unsafe fn is_throwing(env: Env) -> bool {
  function catch_error (line 16) | pub unsafe fn catch_error(env: Env, error: *mut Local) -> bool {
  function clear_exception (line 26) | pub unsafe fn clear_exception(env: Env) {
  function throw (line 38) | pub unsafe fn throw(env: Env, val: Local) {
  function new_error (line 42) | pub unsafe fn new_error(env: Env, out: &mut Local, msg: Local) {
  function new_type_error (line 49) | pub unsafe fn new_type_error(env: Env, out: &mut Local, msg: Local) {
  function new_range_error (line 56) | pub unsafe fn new_range_error(env: Env, out: &mut Local, msg: Local) {
  function throw_error_from_utf8 (line 63) | pub unsafe fn throw_error_from_utf8(env: Env, msg: *const u8, len: i32) {
  function fatal_error (line 75) | pub(super) unsafe fn fatal_error(message: &str) -> ! {

FILE: crates/neon/src/sys/external.rs
  function finalize_external (line 10) | extern "C" fn finalize_external<T: 'static>(
  function deref (line 31) | pub unsafe fn deref<T: 'static>(env: Env, local: Local) -> Option<*const...
  function create (line 60) | pub unsafe fn create<T: 'static>(env: Env, v: T, finalizer: fn(Env, T)) ...

FILE: crates/neon/src/sys/fun.rs
  function new (line 10) | pub unsafe fn new<F>(env: Env, name: &str, callback: F) -> Result<Local,...
  function call_boxed (line 66) | unsafe extern "C" fn call_boxed<F>(env: Env, info: napi::CallbackInfo) -...
  function construct (line 86) | pub unsafe fn construct(

FILE: crates/neon/src/sys/lifecycle.rs
  function set_instance_data (line 17) | pub unsafe fn set_instance_data<T: Send + 'static>(env: Env, data: T) ->...
  function get_instance_data (line 30) | pub unsafe fn get_instance_data<T: Send + 'static>(env: Env) -> *mut T {
  function drop_box (line 38) | unsafe extern "C" fn drop_box<T>(_env: Env, data: *mut c_void, _hint: *m...

FILE: crates/neon/src/sys/mem.rs
  function strict_equals (line 6) | pub unsafe fn strict_equals(env: Env, lhs: Local, rhs: Local) -> bool {

FILE: crates/neon/src/sys/mod.rs
  function string (line 112) | unsafe fn string(env: Env, s: impl AsRef<str>) -> raw::Local {
  function setup (line 136) | pub unsafe fn setup(env: Env) {

FILE: crates/neon/src/sys/no_panic.rs
  type Panic (line 26) | type Panic = Box<dyn Any + Send + 'static>;
  constant UNKNOWN_PANIC_MESSAGE (line 28) | const UNKNOWN_PANIC_MESSAGE: &str = "Unknown panic";
  type FailureBoundary (line 42) | pub struct FailureBoundary {
    method catch_failure (line 50) | pub unsafe fn catch_failure<F>(&self, env: Env, deferred: Option<napi:...
  function can_call_into_js (line 135) | fn can_call_into_js(env: Env) -> bool {
  function fatal_exception (line 142) | unsafe fn fatal_exception(env: Env, error: Local) {
  function create_error (line 157) | unsafe fn create_error(
  function resolve_deferred (line 180) | unsafe fn resolve_deferred(env: Env, deferred: napi::Deferred, value: Lo...
  function reject_deferred (line 187) | unsafe fn reject_deferred(env: Env, deferred: napi::Deferred, value: Loc...
  function catch_exception (line 194) | unsafe fn catch_exception(env: Env) -> Option<Local> {
  function error_from_message (line 209) | unsafe fn error_from_message(env: Env, msg: &str) -> Local {
  function error_from_panic (line 222) | unsafe fn error_from_panic(env: Env, panic: Panic) -> Local {
  function set_property (line 235) | unsafe fn set_property(env: Env, object: Local, key: &str, value: Local) {
  function panic_msg (line 244) | unsafe fn panic_msg(panic: &Panic) -> Option<&str> {
  function external_from_panic (line 254) | unsafe fn external_from_panic(env: Env, panic: Panic) -> Local {
  function finalize_panic (line 280) | extern "C" fn finalize_panic(_env: Env, data: *mut c_void, _hint: *mut c...
  function create_string (line 287) | unsafe fn create_string(env: Env, msg: &str) -> Local {
  function is_exception_pending (line 297) | unsafe fn is_exception_pending(env: Env) -> bool {

FILE: crates/neon/src/sys/object.rs
  function new (line 9) | pub unsafe fn new(out: &mut Local, env: Env) {
  function freeze (line 14) | pub unsafe fn freeze(env: Env, obj: Local) -> Result<(), napi::Status> {
  function seal (line 24) | pub unsafe fn seal(env: Env, obj: Local) -> Result<(), napi::Status> {
  function get_own_property_names (line 31) | pub unsafe fn get_own_property_names(out: &mut Local, env: Env, object: ...
  function get_index (line 52) | pub unsafe fn get_index(out: &mut Local, env: Env, object: Local, index:...
  function set_index (line 65) | pub unsafe fn set_index(out: &mut bool, env: Env, object: Local, index: ...
  function get_string (line 73) | pub unsafe fn get_string(
  function set_string (line 104) | pub unsafe fn set_string(
  function get (line 137) | pub unsafe fn get(out: &mut Local, env: Env, object: Local, key: Local) ...
  function set (line 149) | pub unsafe fn set(out: &mut bool, env: Env, object: Local, key: Local, v...

FILE: crates/neon/src/sys/primitive.rs
  function undefined (line 7) | pub unsafe fn undefined(out: &mut Local, env: Env) {
  function null (line 12) | pub unsafe fn null(out: &mut Local, env: Env) {
  function boolean (line 17) | pub unsafe fn boolean(out: &mut Local, env: Env, b: bool) {
  function boolean_value (line 23) | pub unsafe fn boolean_value(env: Env, p: Local) -> bool {
  function number (line 34) | pub unsafe fn number(out: &mut Local, env: Env, v: f64) {
  function number_value (line 40) | pub unsafe fn number_value(env: Env, p: Local) -> f64 {

FILE: crates/neon/src/sys/promise.rs
  function create (line 14) | pub unsafe fn create(env: Env) -> (napi::Deferred, napi::Value) {
  function resolve (line 28) | pub unsafe fn resolve(env: Env, deferred: napi::Deferred, resolution: na...
  function reject (line 37) | pub unsafe fn reject(env: Env, deferred: napi::Deferred, rejection: napi...
  function reject_err_message (line 46) | pub unsafe fn reject_err_message(env: Env, deferred: napi::Deferred, msg...

FILE: crates/neon/src/sys/raw.rs
  type Local (line 3) | pub type Local = napi::Value;
  type FunctionCallbackInfo (line 5) | pub type FunctionCallbackInfo = napi::CallbackInfo;
  type Env (line 7) | pub type Env = napi::Env;

FILE: crates/neon/src/sys/reference.rs
  function new (line 8) | pub unsafe fn new(env: Env, value: Local) -> napi::Ref {
  function reference (line 18) | pub unsafe fn reference(env: Env, value: napi::Ref) -> usize {
  function unreference (line 28) | pub unsafe fn unreference(env: Env, value: napi::Ref) {
  function get (line 40) | pub unsafe fn get(env: Env, value: napi::Ref) -> Local {

FILE: crates/neon/src/sys/scope.rs
  type HandleScope (line 8) | pub(crate) struct HandleScope {
    method new (line 14) | pub(crate) unsafe fn new(env: Env) -> Self {
  method drop (line 27) | fn drop(&mut self) {
  type EscapableHandleScope (line 36) | pub(crate) struct EscapableHandleScope {
    method new (line 42) | pub(crate) unsafe fn new(env: Env) -> Self {
    method escape (line 53) | pub(crate) unsafe fn escape(&self, value: napi::Value) -> napi::Value {
  method drop (line 63) | fn drop(&mut self) {
  function get_global (line 72) | pub unsafe fn get_global(env: Env, out: &mut Local) {

FILE: crates/neon/src/sys/string.rs
  function new (line 8) | pub unsafe fn new(out: &mut Local, env: Env, data: *const u8, len: i32) ...
  function utf8_len (line 14) | pub unsafe fn utf8_len(env: Env, value: Local) -> usize {
  function data (line 21) | pub unsafe fn data(env: Env, out: *mut u8, len: usize, value: Local) -> ...
  function utf16_len (line 29) | pub unsafe fn utf16_len(env: Env, value: Local) -> usize {
  function data_utf16 (line 37) | pub unsafe fn data_utf16(env: Env, out: *mut u16, len: usize, value: Loc...
  function run_script (line 44) | pub unsafe fn run_script(out: &mut Local, env: Env, value: Local) -> bool {

FILE: crates/neon/src/sys/tag.rs
  function is_type (line 7) | unsafe fn is_type(env: Env, val: Local, expect: napi::ValueType) -> bool {
  function is_undefined (line 13) | pub unsafe fn is_undefined(env: Env, val: Local) -> bool {
  function is_null (line 17) | pub unsafe fn is_null(env: Env, val: Local) -> bool {
  function is_number (line 22) | pub unsafe fn is_number(env: Env, val: Local) -> bool {
  function is_boolean (line 27) | pub unsafe fn is_boolean(env: Env, val: Local) -> bool {
  function is_string (line 32) | pub unsafe fn is_string(env: Env, val: Local) -> bool {
  function is_object (line 36) | pub unsafe fn is_object(env: Env, val: Local) -> bool {
  function is_array (line 40) | pub unsafe fn is_array(env: Env, val: Local) -> bool {
  function is_function (line 46) | pub unsafe fn is_function(env: Env, val: Local) -> bool {
  function is_error (line 50) | pub unsafe fn is_error(env: Env, val: Local) -> bool {
  function is_buffer (line 57) | pub unsafe fn is_buffer(env: Env, val: Local) -> bool {
  function is_arraybuffer (line 64) | pub unsafe fn is_arraybuffer(env: Env, val: Local) -> bool {
  function is_typedarray (line 71) | pub unsafe fn is_typedarray(env: Env, val: Local) -> bool {
  function is_date (line 78) | pub unsafe fn is_date(env: Env, val: Local) -> bool {
  function is_promise (line 88) | pub unsafe fn is_promise(env: Env, val: Local) -> bool {
  function type_tag_object (line 95) | pub unsafe fn type_tag_object(env: Env, object: Local, tag: &super::Type...
  function check_object_type_tag (line 100) | pub unsafe fn check_object_type_tag(env: Env, object: Local, tag: &super...
  function is_bigint (line 108) | pub unsafe fn is_bigint(env: Env, val: Local) -> bool {

FILE: crates/neon/src/sys/tsfn.rs
  constant BOUNDARY (line 12) | const BOUNDARY: FailureBoundary = FailureBoundary {
  type Tsfn (line 19) | struct Tsfn(napi::ThreadsafeFunction);
  type ThreadsafeFunction (line 28) | pub struct ThreadsafeFunction<T> {
  type Callback (line 35) | struct Callback<T> {
  type CallError (line 41) | pub struct CallError;
  function new (line 46) | pub unsafe fn new(env: Env, callback: fn(Option<Env>, T)) -> Self {
  function with_capacity (line 52) | pub unsafe fn with_capacity(
  function call (line 87) | pub fn call(
  function reference (line 131) | pub unsafe fn reference(&self, env: Env) {
  function unref (line 137) | pub unsafe fn unref(&self, env: Env) {
  function finalize (line 143) | unsafe extern "C" fn finalize(_env: Env, data: *mut c_void, _hint: *mut ...
  function callback (line 160) | unsafe extern "C" fn callback(
  method drop (line 176) | fn drop(&mut self) {

FILE: crates/neon/src/sys/typedarray.rs
  type TypedArrayInfo (line 10) | pub struct TypedArrayInfo {
  function info (line 23) | pub unsafe fn info(env: Env, value: Local) -> TypedArrayInfo {
  function new (line 43) | pub unsafe fn new(

FILE: crates/neon/src/thread/mod.rs
  function next_id (line 115) | fn next_id() -> usize {
  type LocalKey (line 130) | pub struct LocalKey<T> {
  function new (line 138) | pub const fn new() -> Self {
  function id (line 145) | fn id(&self) -> usize {
  function get (line 153) | pub fn get<'cx, 'a, C>(&self, cx: &'a mut C) -> Option<&'cx T>
  function get_or_init (line 169) | pub fn get_or_init<'cx, 'a, C, F>(&self, cx: &'a mut C, f: F) -> &'cx T
  function get_or_try_init (line 193) | pub fn get_or_try_init<'cx, 'a, C, E, F>(&self, cx: &'a mut C, f: F) -> ...
  function get_or_init_default (line 213) | pub fn get_or_init_default<'cx, 'a, C>(&self, cx: &'a mut C) -> &'cx T

FILE: crates/neon/src/types_impl/bigint.rs
  type Sign (line 18) | pub enum Sign {
  type RangeError (line 31) | pub struct RangeError<T>(T);
  function into_inner (line 36) | pub fn into_inner(self) -> T {
  function fmt (line 45) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function or_throw (line 56) | fn or_throw<'a, C: Context<'a>>(self, cx: &mut C) -> NeonResult<T> {
  constant POSITIVE (line 62) | pub const POSITIVE: Sign = Sign::Positive;
  constant NEGATIVE (line 63) | pub const NEGATIVE: Sign = Sign::Negative;
  method from_i64 (line 76) | pub fn from_i64<'cx, C>(cx: &mut C, n: i64) -> Handle<'cx, Self>
  method from_u64 (line 101) | pub fn from_u64<'cx, C>(cx: &mut C, n: u64) -> Handle<'cx, Self>
  method from_u128_sign (line 116) | fn from_u128_sign<'cx, C>(cx: &mut C, sign: Sign, n: u128) -> Handle<'cx...
  method from_i128 (line 137) | pub fn from_i128<'cx, C>(cx: &mut C, n: i128) -> Handle<'cx, Self>
  method from_u128 (line 162) | pub fn from_u128<'cx, C>(cx: &mut C, n: u128) -> Handle<'cx, Self>
  method from_digits_le (line 191) | pub fn from_digits_le<'cx, C>(cx: &mut C, sign: Sign, digits: &[u64]) ->...
  method to_i64 (line 224) | pub fn to_i64<'cx, C>(&self, cx: &mut C) -> Result<i64, RangeError<i64>>
  method to_u64 (line 245) | pub fn to_u64<'cx, C>(&self, cx: &mut C) -> Result<u64, RangeError<u64>>
  method to_i128 (line 266) | pub fn to_i128<'cx, C>(&self, cx: &mut C) -> Result<i128, RangeError<i128>>
  method to_u128 (line 307) | pub fn to_u128<'cx, C>(&self, cx: &mut C) -> Result<u128, RangeError<u128>>
  method to_digits_le (line 331) | pub fn to_digits_le<'cx, C>(&self, cx: &mut C) -> (Sign, Vec<u64>)
  method read_digits_le (line 370) | pub fn read_digits_le<'cx, C>(&self, cx: &mut C, digits: &mut [u64]) -> ...
  method len (line 398) | pub fn len<'cx, C>(&self, cx: &mut C) -> usize
  type Inner (line 410) | type Inner = raw::Local;
  method into_inner (line 412) | fn into_inner(self) -> Self::Inner {
  method name (line 418) | fn name() -> &'static str {
  method is_typeof (line 422) | fn is_typeof<Other: Value>(cx: &mut Cx, other: &Other) -> bool {
  method to_local (line 426) | fn to_local(&self) -> raw::Local {
  method from_local (line 430) | unsafe fn from_local(_env: Env, h: raw::Local) -> Self {

FILE: crates/neon/src/types_impl/boxed.rs
  type BoxAny (line 17) | type BoxAny = Box<dyn Any + 'static>;
  type JsBoxInner (line 20) | pub struct JsBoxInner<T: 'static> {
  type JsBox (line 147) | pub struct JsBox<T: 'static>(JsBoxInner<T>);
  function fmt (line 150) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function fmt (line 156) | fn fmt(&self, f: &mut std::fmt::Formatter<'_>) -> std::fmt::Result {
  function maybe_external_deref (line 163) | unsafe fn maybe_external_deref<'a>(env: Env, local: raw::Local) -> Optio...
  method clone (line 169) | fn clone(&self) -> Self {
  type Inner (line 181) | type Inner = JsBoxInner<T>;
  method into_inner (line 183) | fn into_inner(self) -> Self::Inner {
  method name (line 189) | fn name() -> &'static str {
  method is_typeof (line 193) | fn is_typeof<Other: Value>(cx: &mut Cx, other: &Other) -> bool {
  method downcast (line 199) | fn downcast<Other: Value>(cx: &mut Cx, other: &Other) -> Option<Self> {
  method to_local (line 208) | fn to_local(&self) -> raw::Local {
  method from_local (line 212) | unsafe fn from_local(env: Env, local: raw::Local) -> Self {
  function new (line 237) | pub fn new<'cx, C: Context<'cx>>(cx: &mut C, value: T) -> Handle<'cx, Js...
  function manually_finalize (line 254) | pub(crate) fn manually_finalize<'cx>(cx: &mut Cx<'cx>, value: T) -> Hand...
  function create_external (line 260) | fn create_external<'cx, C: Context<'cx>>(
  function deref (line 282) | pub fn deref<'cx>(v: &Handle<'cx, Self>) -> &'cx T {
  function as_inner (line 293) | pub fn as_inner(&self) -> &'cx T {
  type Target (line 302) | type Target = T;
  method deref (line 304) | fn deref(&self) -> &Self::Target {
  type Finalize (line 346) | pub trait Finalize: Sized {
    method finalize (line 347) | fn finalize<'a, C: Context<'a>>(self, _: &mut C) {}
    method finalize (line 413) | fn finalize<'a, C: Context<'a>>(self, cx: &mut C) {
    method finalize (line 423) | fn finalize<'a, C: Context<'a>>(self, cx: &mut C) {
    method finalize (line 429) | fn finalize<'a, C: Context<'a>>(self, cx: &mut C) {
    method finalize (line 437) | fn finalize<'a, C: Context<'a>>(self, cx: &mut C) {
    method finalize (line 445) | fn finalize<'a, C: Context<'a>>(self, cx: &mut C) {
    method finalize (line 453) | fn finalize<'a, C: Context<'a>>(self, cx: &mut C) {
    method finalize (line 461) | fn finalize<'a, C: Context<'a>>(self, cx: &mut C) {
    method finalize (line 469) | fn finalize<'a, C: Context<'a>>(self, cx: &mut C) {
    method finalize (line 475) | fn finalize<'a, C: Context<'a>>(self, cx: &mut C) {

FILE: crates/neon/src/types_impl/buffer/lock.rs
  type Lock (line 15) | pub struct Lock<'cx, C> {
  function new (line 25) | pub fn new(cx: &'cx mut C) -> Lock<'cx, C> {
  type Ledger (line 37) | pub(super) struct Ledger {
    method slice_to_range (line 49) | pub(super) fn slice_to_range<T>(data: &[T]) -> Range<*const u8> {
    method try_borrow (line 57) | pub(super) fn try_borrow<'a, T>(
    method try_borrow_mut (line 70) | pub(super) fn try_borrow_mut<'a, T>(
    method try_add_borrow (line 82) | fn try_add_borrow<T>(&mut self, data: &[T]) -> Result<(), BorrowError> {
    method try_add_borrow_mut (line 95) | fn try_add_borrow_mut<T>(&mut self, data: &mut [T]) -> Result<(), Borr...
  function is_disjoint (line 111) | fn is_disjoint(a: &Range<*const u8>, b: &Range<*const u8>) -> bool {
  function check_overlap (line 115) | fn check_overlap(
  function unsafe_aliased_slice (line 136) | fn unsafe_aliased_slice<T>(data: &mut [T]) -> &'static mut [T] {
  function test_overlapping_immutable_borrows (line 141) | fn test_overlapping_immutable_borrows() -> Result<(), Box<dyn Error>> {
  function test_nonoverlapping_borrows (line 153) | fn test_nonoverlapping_borrows() -> Result<(), Box<dyn Error>> {
  function test_overlapping_borrows (line 165) | fn test_overlapping_borrows() -> Result<(), Box<dyn Error>> {

FILE: crates/neon/src/types_impl/buffer/mod.rs
  type TypedArray (line 50) | pub trait TypedArray: Value {
    method as_slice (line 57) | fn as_slice<'cx, 'a, C>(&self, cx: &'a C) -> &'a [Self::Item]
    method as_mut_slice (line 65) | fn as_mut_slice<'cx, 'a, C>(&mut self, cx: &'a mut C) -> &'a mut [Self...
    method try_borrow (line 75) | fn try_borrow<'cx, 'a, C>(&self, lock: &'a Lock<C>) -> Result<Ref<'a, ...
    method try_borrow_mut (line 85) | fn try_borrow_mut<'cx, 'a, C>(
    method size (line 93) | fn size<'cx, C>(&self, cx: &mut C) -> usize
    method from_slice (line 98) | fn from_slice<'cx, C>(cx: &mut C, slice: &[Self::Item]) -> JsResult<'c...
  type Ref (line 105) | pub struct Ref<'a, T> {
  type RefMut (line 112) | pub struct RefMut<'a, T> {
  type Target (line 118) | type Target = [T];
  method deref (line 120) | fn deref(&self) -> &Self::Target {
  type Target (line 126) | type Target = [T];
  method deref (line 128) | fn deref(&self) -> &Self::Target {
  method deref_mut (line 134) | fn deref_mut(&mut self) -> &mut Self::Target {
  method drop (line 140) | fn drop(&mut self) {
  method drop (line 154) | fn drop(&mut self) {
  type BorrowError (line 172) | pub struct BorrowError {
    method new (line 177) | fn new() -> Self {
  method fmt (line 185) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  method fmt (line 191) | fn fmt(&self, f: &mut fmt::Formatter<'_>) -> fmt::Result {
  function or_throw (line 197) | fn or_throw<'a, C: Context<'a>>(self, cx: &mut C) -> NeonResult<T> {
  type Region (line 236) | pub struct Region<'cx, T: Binary> {
  function buffer (line 249) | pub fn buffer(&self) -> Handle<'cx, JsArrayBuffer> {
  function offset (line 254) | pub fn offset(&self) -> usize {
  function len (line 260) | pub fn len(&self) -> usize {
  function size (line 266) | pub fn size(&self) -> usize {
  function to_typed_array (line 278) | pub fn to_typed_array<'c, C>(&self, cx: &mut C) -> JsResult<'c, JsTypedA...
  type Sealed (line 292) | pub trait Sealed {}
  type JsTypedArrayInner (line 295) | pub struct JsTypedArrayInner<T: Binary> {
  method fmt (line 302) | fn fmt(&self, f: &mut Formatter) -> Result<(), std::fmt::Error> {

FILE: crates/neon/src/types_impl/buffer/types.rs
  type JsBuffer (line 54) | pub struct JsBuffer(raw::Local);
    method new (line 60) | pub fn new<'a, C: Context<'a>>(cx: &mut C, len: usize) -> JsResult<'a,...
    method from_slice (line 76) | pub fn from_slice<'cx, C>(cx: &mut C, slice: &[u8]) -> JsResult<'cx, S...
    method uninitialized (line 84) | pub unsafe fn uninitialized<'a, C: Context<'a>>(cx: &mut C, len: usize...
    method external (line 109) | pub fn external<'a, C, T>(cx: &mut C, data: T) -> Handle<'a, Self>
  type Inner (line 122) | type Inner = raw::Local;
  method into_inner (line 124) | fn into_inner(self) -> Self::Inner {
  method name (line 130) | fn name() -> &'static str {
  method is_typeof (line 134) | fn is_typeof<Other: Value>(cx: &mut Cx, other: &Other) -> bool {
  method to_local (line 138) | fn to_local(&self) -> raw::Local {
  method from_local (line 142) | unsafe fn from_local(_env: Env, h: raw::Local) -> Self {
  type Item (line 154) | type Item = u8;
  method as_slice (line 156) | fn as_slice<'cx, 'a, C>(&self, cx: &'a C) -> &'a [Self::Item]
  method as_mut_slice (line 169) | fn as_mut_slice<'cx, 'a, C>(&mut self, cx: &'a mut C) -> &'a mut [Self::...
  method try_borrow (line 178) | fn try_borrow<'cx, 'a, C>(&self, lock: &'a Lock<C>) -> Result<Ref<'a, Se...
  method try_borrow_mut (line 188) | fn try_borrow_mut<'cx, 'a, C>(
  method size (line 201) | fn size<'cx, C: Context<'cx>>(&self, cx: &mut C) -> usize {
  method from_slice (line 205) | fn from_slice<'cx, C>(cx: &mut C, slice: &[u8]) -> JsResult<'cx, Self>
  type JsArrayBuffer (line 239) | pub struct JsArrayBuffer(raw::Local);
    method new (line 245) | pub fn new<'a, C: Context<'a>>(cx: &mut C, len: usize) -> JsResult<'a,...
    method from_slice (line 261) | pub fn from_slice<'cx, C>(cx: &mut C, slice: &[u8]) -> JsResult<'cx, S...
    method external (line 283) | pub fn external<'a, C, T>(cx: &mut C, data: T) -> Handle<'a, Self>
    method region (line 298) | pub fn region<'cx, T: Binary>(
  function region (line 328) | pub fn region<T: Binary>(&self, offset: usize, len: usize) -> Region<'cx...
  type Inner (line 339) | type Inner = raw::Local;
  method into_inner (line 341) | fn into_inner(self) -> Self::Inner {
  method name (line 347) | fn name() -> &'static str {
  method is_typeof (line 351) | fn is_typeof<Other: Value>(cx: &mut Cx, other: &Other) -> bool {
  method to_local (line 355) | fn to_local(&self) -> raw::Local {
  method from_local (line 359) | unsafe fn from_local(_env: Env, h: raw::Local) -> Self {
  type Item (line 371) | type Item = u8;
  method as_slice (line 373) | fn as_slice<'cx, 'a, C>(&self, cx: &'a C) -> &'a [Self::Item]
  method as_mut_slice (line 380) | fn as_mut_slice<'cx, 'a, C>(&mut self, cx: &'a mut C) -> &'a mut [Self::...
  method try_borrow (line 387) | fn try_borrow<'cx, 'a, C>(&self, lock: &'a Lock<C>) -> Result<Ref<'a, Se...
  method try_borrow_mut (line 397) | fn try_borrow_mut<'cx, 'a, C>(
  method size (line 410) | fn size<'cx, C: Context<'cx>>(&self, cx: &mut C) -> usize {
  method from_slice (line 414) | fn from_slice<'cx, C>(cx: &mut C, slice: &[u8]) -> JsResult<'cx, Self>
  type Binary (line 429) | pub trait Binary: private::Sealed + Copy {
    constant TYPE_TAG (line 431) | const TYPE_TAG: TypedArrayType;
  type JsTypedArray (line 527) | pub struct JsTypedArray<T: Binary>(JsTypedArrayInner<T>);
  type Inner (line 532) | type Inner = JsTypedArrayInner<T>;
  method into_inner (line 534) | fn into_inner(self) -> Self::Inner {
  type Item (line 544) | type Item = T;
  method as_slice (line 546) | fn as_slice<'cx, 'a, C>(&self, cx: &'a C) -> &'a [Self::Item]
  method as_mut_slice (line 559) | fn as_mut_slice<'cx, 'a, C>(&mut self, cx: &'a mut C) -> &'a mut [Self::...
  method try_borrow (line 572) | fn try_borrow<'cx, 'b, C>(
  method try_borrow_mut (line 589) | fn try_borrow_mut<'cx, 'a, C>(
  method size (line 606) | fn size<'cx, C: Context<'cx>>(&self, cx: &mut C) -> usize {
  method from_slice (line 610) | fn from_slice<'cx, C>(cx: &mut C, slice: &[T]) -> JsResult<'cx, Self>
  function from_slice (line 634) | pub fn from_slice<'cx, C>(cx: &mut C, slice: &[T]) -> JsResult<'cx, Self>
  function from_buffer (line 650) | pub fn from_buffer<'cx, 'b: 'cx, C>(
  function from_region (line 678) | pub fn from_region<'c, 'r, C>(cx: &mut C, region: &Region<'r, T>) -> JsR...
  function region (line 708) | pub fn region<'cx, C>(&self, cx: &mut C) -> Region<'cx, T>
  function new (line 727) | pub fn new<'cx, C>(cx: &mut C, len: usize) -> JsResult<'cx, Self>
  function buffer (line 742) | pub fn buffer<'cx, C>(&self, cx: &mut C) -> Handle<'cx, JsArrayBuffer>
  function offset (line 751) | pub fn offset<'cx, C>(&self, cx: &mut C) -> usize
  function len (line 768) | pub fn len<'cx, C>(&self, cx: &mut C) -> usize
  function slice_from_info (line 777) | unsafe fn slice_from_info<'a, T>(info: TypedArrayInfo) -> &'a [T] {
  function slice_from_info_mut (line 785) | unsafe fn slice_from_info_mut<'a, T>(info: TypedArrayInfo) -> &'a mut [T] {

FILE: crates/neon/src/types_impl/date.rs
  type JsDate (line 55) | pub struct JsDate(raw::Local);
    constant MIN_VALUE (line 117) | pub const MIN_VALUE: f64 = -8.64e15;
    constant MAX_VALUE (line 120) | pub const MAX_VALUE: f64 = 8.64e15;
    method new (line 125) | pub fn new<'a, C: Context<'a>, T: Into<f64>>(
    method new_lossy (line 145) | pub fn new_lossy<'a, C: Context<'a>, V: Into<f64>>(cx: &mut C, value: ...
    method value (line 152) | pub fn value<'a, C: Context<'a>>(&self, cx: &mut C) -> f64 {
    method is_valid (line 159) | pub fn is_valid<'a, C: Context<'a>>(&self, cx: &mut C) -> bool {
  type Inner (line 60) | type Inner = raw::Local;
  method into_inner (line 62) | fn into_inner(self) -> Self::Inner {
  type DateError (line 70) | pub struct DateError(DateErrorKind);
    method kind (line 73) | pub fn kind(&self) -> DateErrorKind {
    method fmt (line 79) | fn fmt(&self, fmt: &mut fmt::Formatter) -> fmt::Result {
  type DateErrorKind (line 89) | pub enum DateErrorKind {
    method as_str (line 99) | fn as_str(&self) -> &'static str {
  function or_throw (line 109) | fn or_throw<'b, C: Context<'b>>(self, cx: &mut C) -> JsResult<'a, T> {
  method name (line 166) | fn name() -> &'static str {
  method is_typeof (line 170) | fn is_typeof<Other: Value>(cx: &mut Cx, other: &Other) -> bool {
  method to_local (line 174) | fn to_local(&self) -> raw::Local {
  method from_local (line 178) | unsafe fn from_local(_env: Env, h: raw::Local) -> Self {

FILE: crates/neon/src/types_impl/error.rs
  type JsError (line 40) | pub struct JsError(raw::Local);
    method error (line 76) | pub fn error<'a, C: Context<'a>, S: AsRef<str>>(
    method type_error (line 90) | pub fn type_error<'a, C: Context<'a>, S: AsRef<str>>(
    method range_error (line 104) | pub fn range_error<'a, C: Context<'a>, S: AsRef<str>>(
  type Inner (line 43) | type Inner = raw::Local;
  method into_inner (line 45) | fn into_inner(self) -> Self::Inner {
  method name (line 51) | fn name() -> &'static str {
  method is_typeof (line 55) | fn is_typeof<Other: Value>(cx: &mut Cx, other: &Other) -> bool {
  method to_local (line 59) | fn to_local(&self) -> raw::Local {
  method from_local (line 63) | unsafe fn from_local(_env: Env, h: raw::Local) -> Self {
  function convert_panics (line 116) | pub(crate) fn convert_panics<T, F: UnwindSafe + FnOnce() -> NeonResult<T>>(

FILE: crates/neon/src/types_impl/extract/array.rs
  type Array (line 43) | pub struct Array<T>(pub T);
  type Error (line 53) | type Error = ArrayError<<T::Item as TryFromJs<'cx>>::Error>;
  function try_from_js (line 55) | fn try_from_js(
  type Value (line 102) | type Value = JsArray;
  function try_into_js (line 104) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
  type ArrayError (line 139) | pub enum ArrayError<E> {
  function array (line 147) | fn array() -> Self {
  function item (line 151) | fn item(err: E) -> Self {
  function fmt (line 160) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type Value (line 174) | type Value = JsValue;
  function try_into_js (line 176) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {

FILE: crates/neon/src/types_impl/extract/boxed.rs
  type Boxed (line 45) | pub struct Boxed<T>(pub T);
  type Error (line 51) | type Error = TypeExpected<JsBox<T>>;
  function try_from_js (line 53) | fn try_from_js(
  type Value (line 68) | type Value = JsBox<T>;
  function try_into_js (line 70) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {

FILE: crates/neon/src/types_impl/extract/buffer.rs
  type ArrayBuffer (line 15) | pub struct ArrayBuffer<B>(pub B);
  type Error (line 21) | type Error = TypeExpected<JsBuffer>;
  function try_from_js (line 23) | fn try_from_js(
  type Value (line 40) | type Value = JsArrayBuffer;
  function try_into_js (line 42) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
  type Buffer (line 50) | pub struct Buffer<B>(pub B);
  type Error (line 56) | type Error = TypeExpected<JsBuffer>;
  function try_from_js (line 58) | fn try_from_js(
  type Value (line 75) | type Value = JsBuffer;
  function try_into_js (line 77) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
  type Value (line 89) | type Value = JsTypedArray<T>;
  function try_into_js (line 91) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
  type Error (line 101) | type Error = TypeExpected<JsTypedArray<T>>;
  function try_from_js (line 103) | fn try_from_js(
  type Value (line 128) | type Value = JsTypedArray<T>;
  function try_into_js (line 130) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
  type Value (line 147) | type Value = JsTypedArray<T>;
  function try_into_js (line 149) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {

FILE: crates/neon/src/types_impl/extract/container.rs
  type Error (line 20) | type Error = TypeExpected<JsBox<RefCell<T>>>;
  function try_from_js (line 22) | fn try_from_js(
  type Error (line 34) | type Error = TypeExpected<JsBox<RefCell<T>>>;
  function try_from_js (line 36) | fn try_from_js(
  type Error (line 51) | type Error = TypeExpected<JsBox<RefCell<T>>>;
  function try_from_js (line 53) | fn try_from_js(
  type Value (line 71) | type Value = JsBox<RefCell<T>>;
  function try_into_js (line 73) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
  type Error (line 79) | type Error = TypeExpected<JsBox<Rc<T>>>;
  function try_from_js (line 81) | fn try_from_js(
  type Value (line 96) | type Value = JsBox<Rc<T>>;
  function try_into_js (line 98) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
  type Error (line 104) | type Error = TypeExpected<JsBox<Arc<T>>>;
  function try_from_js (line 106) | fn try_from_js(
  type Value (line 121) | type Value = JsBox<Arc<T>>;
  function try_into_js (line 123) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
  type Value (line 134) | type Value = V;
  function try_into_js (line 136) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {

FILE: crates/neon/src/types_impl/extract/either.rs
  type Error (line 21) | type Error = Error<L::Error, R::Error>;
  function try_from_js (line 23) | fn try_from_js(
  type Value (line 46) | type Value = JsValue;
  function try_into_js (line 48) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
  type Error (line 59) | pub struct Error<L, R> {
  function new (line 65) | fn new<LT, RT>(left: L, right: R) -> Self
  function fmt (line 82) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type Value (line 100) | type Value = JsError;
  function try_into_js (line 102) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {

FILE: crates/neon/src/types_impl/extract/error.rs
  type BoxError (line 12) | type BoxError = Box<dyn error::Error + Send + Sync + 'static>;
  type TypeExpected (line 15) | pub struct TypeExpected<T: Value>(PhantomData<T>);
  function new (line 18) | pub(super) fn new() -> Self {
  function fmt (line 24) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  function fmt (line 30) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type Value (line 38) | type Value = JsError;
  function try_into_js (line 40) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
  type Value (line 48) | type Value = JsValue;
  method try_into_js (line 50) | fn try_into_js(self, _: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
  type Error (line 74) | pub struct Error {
    method new (line 88) | pub fn new<E>(cause: E) -> Self
    method range_error (line 96) | pub fn range_error<E>(cause: E) -> Self
    method type_error (line 104) | pub fn type_error<E>(cause: E) -> Self
    method is_range_error (line 112) | pub fn is_range_error(&self) -> bool {
    method is_type_error (line 117) | pub fn is_type_error(&self) -> bool {
    method cause (line 122) | pub fn cause(&self) -> &BoxError {
    method into_cause (line 127) | pub fn into_cause(self) -> BoxError {
    method create (line 131) | fn create<E>(kind: ErrorKind, cause: E) -> Self
    method from (line 147) | fn from(cause: E) -> Self {
    method fmt (line 153) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    type Value (line 161) | type Value = JsError;
    method try_into_js (line 163) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
  type ErrorKind (line 80) | enum ErrorKind {

FILE: crates/neon/src/types_impl/extract/json.rs
  function global_json_stringify (line 33) | fn global_json_stringify<'cx>(cx: &mut Cx<'cx>) -> JsResult<'cx, JsFunct...
  function json_stringify (line 42) | fn json_stringify<'cx>(cx: &mut Cx<'cx>) -> JsResult<'cx, JsFunction> {
  function json_stringify (line 47) | fn json_stringify<'cx>(cx: &mut Cx<'cx>) -> JsResult<'cx, JsFunction> {
  function global_json_parse (line 55) | fn global_json_parse<'cx>(cx: &mut Cx<'cx>) -> JsResult<'cx, JsFunction> {
  function json_parse (line 60) | fn json_parse<'cx>(cx: &mut Cx<'cx>) -> JsResult<'cx, JsFunction> {
  function json_parse (line 65) | fn json_parse<'cx>(cx: &mut Cx<'cx>) -> JsResult<'cx, JsFunction> {
  function parse (line 73) | fn parse<'cx>(cx: &mut Cx<'cx>, s: &str) -> JsResult<'cx, JsValue> {
  type Json (line 81) | pub struct Json<T>(pub T);
  type Error (line 87) | type Error = Error;
    method fmt (line 136) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method fmt (line 142) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    type Value (line 150) | type Value = JsError;
    method try_into_js (line 152) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
  function try_from_js (line 89) | fn try_from_js(
  type Value (line 108) | type Value = JsValue;
  function try_into_js (line 110) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
  type Value (line 119) | type Value = JsValue;
  function try_into_js (line 121) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
  type Error (line 133) | pub struct Error(serde_json::Error);
    method fmt (line 136) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    method fmt (line 142) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
    type Value (line 150) | type Value = JsError;
    method try_into_js (line 152) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {

FILE: crates/neon/src/types_impl/extract/mod.rs
  type TryFromJs (line 140) | pub trait TryFromJs<'cx>
    method try_from_js (line 147) | fn try_from_js(
    method from_js (line 153) | fn from_js(cx: &mut Cx<'cx>, v: Handle<'cx, JsValue>) -> NeonResult<Se...
  type TryIntoJs (line 166) | pub trait TryIntoJs<'cx>
    method try_into_js (line 174) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value>;
  type TryFromJsRef (line 193) | pub trait TryFromJsRef<'cx>
    method try_from_js_ref (line 204) | fn try_from_js_ref(
    method from_js_ref (line 210) | fn from_js_ref(cx: &mut Cx<'cx>, v: Handle<'cx, JsValue>) -> NeonResul...
  type TryFromJsRefMut (line 238) | pub trait TryFromJsRefMut<'cx>
    method try_from_js_ref_mut (line 249) | fn try_from_js_ref_mut(
    method from_js_ref_mut (line 255) | fn from_js_ref_mut(cx: &mut Cx<'cx>, v: Handle<'cx, JsValue>) -> NeonR...
  type Date (line 269) | pub struct Date(pub f64);
  type FromArgs (line 275) | pub trait FromArgs<'cx>: private::FromArgsInternal<'cx> {}
  function from_args (line 279) | fn from_args(_cx: &mut FunctionContext<'cx>) -> NeonResult<Self> {
  function from_args_opt (line 283) | fn from_args_opt(_cx: &mut FunctionContext<'cx>) -> NeonResult<Option<Se...

FILE: crates/neon/src/types_impl/extract/private.rs
  type Sealed (line 18) | pub trait Sealed {}
  type FromArgsInternal (line 20) | pub trait FromArgsInternal<'cx>: Sized {
    method from_args (line 21) | fn from_args(cx: &mut FunctionContext<'cx>) -> NeonResult<Self>;
    method from_args_opt (line 23) | fn from_args_opt(cx: &mut FunctionContext<'cx>) -> NeonResult<Option<S...

FILE: crates/neon/src/types_impl/extract/try_from_js.rs
  type Error (line 28) | type Error = TypeExpected<V>;
  function try_from_js (line 30) | fn try_from_js(
  type Error (line 42) | type Error = TypeExpected<O>;
  function try_from_js (line 44) | fn try_from_js(
  type Error (line 59) | type Error = T::Error;
  function try_from_js (line 61) | fn try_from_js(
  type Error (line 74) | type Error = TypeExpected<JsNumber>;
  function try_from_js (line 76) | fn try_from_js(
  type Error (line 95) | type Error = TypeExpected<JsNumber>;
  function try_from_js (line 97) | fn try_from_js(
  type Error (line 116) | type Error = TypeExpected<JsNumber>;
  function try_from_js (line 118) | fn try_from_js(
  type Error (line 137) | type Error = TypeExpected<JsBoolean>;
  function try_from_js (line 139) | fn try_from_js(
  type Error (line 158) | type Error = TypeExpected<JsString>;
  method try_from_js (line 160) | fn try_from_js(
  type Error (line 203) | type Error = TypeExpected<JsDate>;
  method try_from_js (line 205) | fn try_from_js(
  type Error (line 234) | type Error = Infallible;
  function try_from_js (line 236) | fn try_from_js(
  function is_null_or_undefined (line 244) | fn is_null_or_undefined<V>(cx: &mut Cx, v: Handle<V>) -> NeonResult<bool>

FILE: crates/neon/src/types_impl/extract/try_into_js.rs
  type Value (line 19) | type Value = T;
  function try_into_js (line 21) | fn try_into_js(self, _cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
  type Value (line 30) | type Value = O;
  function try_into_js (line 32) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
  type Value (line 42) | type Value = T::Value;
  function try_into_js (line 44) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
  type Value (line 57) | type Value = JsValue;
  method try_into_js (line 59) | fn try_into_js(self, _cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
  type Value (line 68) | type Value = JsValue;
  function try_into_js (line 70) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
  type Value (line 83) | type Value = T::Value;
  function try_into_js (line 85) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
  type Value (line 111) | type Value = JsString;
  method try_into_js (line 113) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
  type Value (line 119) | type Value = JsString;
  function try_into_js (line 121) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
  type Value (line 127) | type Value = JsString;
  function try_into_js (line 129) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
  type Value (line 135) | type Value = JsBoolean;
  function try_into_js (line 137) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
  type Value (line 143) | type Value = JsUndefined;
  function try_into_js (line 145) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {
  type Value (line 152) | type Value = JsDate;
  method try_into_js (line 154) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {

FILE: crates/neon/src/types_impl/extract/with.rs
  type With (line 7) | struct With<F>(pub F);
  function with (line 42) | pub fn with<V, F>(f: F) -> impl for<'cx> TryIntoJs<'cx, Value = V>
  type Value (line 55) | type Value = O::Value;
  function try_into_js (line 57) | fn try_into_js(self, cx: &mut Cx<'cx>) -> JsResult<'cx, Self::Value> {

FILE: crates/neon/src/types_impl/function/mod.rs
  type BindOptions (line 33) | pub struct BindOptions<'a, 'cx: 'a> {
  function this (line 42) | pub fn this<T: TryIntoJs<'cx>>(&mut self, this: T) -> NeonResult<&mut Se...
  function args (line 49) | pub fn args<A: TryIntoArguments<'cx>>(&mut self, a: A) -> NeonResult<&mu...
  function args_with (line 55) | pub fn args_with<R, F>(&mut self, f: F) -> NeonResult<&mut Self>
  function arg (line 65) | pub fn arg<A: TryIntoJs<'cx>>(&mut self, a: A) -> NeonResult<&mut Self> {
  function arg_with (line 72) | pub fn arg_with<R, F>(&mut self, f: F) -> NeonResult<&mut Self>
  function call (line 84) | pub fn call<R: TryFromJs<'cx>>(&mut self) -> NeonResult<R> {
  function construct (line 92) | pub fn construct<R: TryFromJs<'cx>>(&mut self) -> NeonResult<R> {
  function exec (line 100) | pub fn exec(&mut self) -> NeonResult<()> {
  type CallOptions (line 122) | pub struct CallOptions<'a> {
  function this (line 130) | pub fn this<V: Value>(&mut self, this: Handle<'a, V>) -> &mut Self {
  function arg (line 136) | pub fn arg<V: Value>(&mut self, arg: Handle<'a, V>) -> &mut Self {
  function args (line 142) | pub fn args<A: Arguments<'a>>(&mut self, args: A) -> &mut Self {
  function apply (line 149) | pub fn apply<'b: 'a, V: Value, C: Context<'b>>(&self, cx: &mut C) -> JsR...
  function exec (line 158) | pub fn exec<'b: 'a, C: Context<'b>>(&self, cx: &mut C) -> NeonResult<()> {
  type ConstructOptions (line 181) | pub struct ConstructOptions<'a> {
  function arg (line 188) | pub fn arg<V: Value>(&mut self, arg: Handle<'a, V>) -> &mut Self {
  function args (line 194) | pub fn args<A: Arguments<'a>>(&mut self, args: A) -> &mut Self {
  function apply (line 201) | pub fn apply<'b: 'a, O: Object, C: Context<'b>>(&self, cx: &mut C) -> Js...
  type TryIntoArguments (line 212) | pub trait TryIntoArguments<'cx>: private::TryIntoArgumentsInternal<'cx> {}
  function try_into_args_vec (line 215) | fn try_into_args_vec(self, _cx: &mut Cx<'cx>) -> NeonResult<private::Arg...
  function try_into_args_vec (line 225) | fn try_into_args_vec(self, cx: &mut Cx<'cx>) -> NeonResult<private::Args...
  type Arguments (line 299) | pub trait Arguments<'a>: private::ArgumentsInternal<'a> {}
  function into_args_vec (line 302) | fn into_args_vec(self) -> private::ArgsVec<'a> {

FILE: crates/neon/src/types_impl/function/private.rs
  type ArgsVec (line 5) | pub type ArgsVec<'a> = SmallVec<[Handle<'a, JsValue>; 8]>;
  type TryIntoArgumentsInternal (line 8) | pub trait TryIntoArgumentsInternal<'cx> {
    method try_into_args_vec (line 9) | fn try_into_args_vec(self, cx: &mut Cx<'cx>) -> NeonResult<ArgsVec<'cx>>;
  type ArgumentsInternal (line 13) | pub trait ArgumentsInternal<'a> {
    method into_args_vec (line 14) | fn into_args_vec(self) -> ArgsVec<'a>;

FILE: crates/neon/src/types_impl/mod.rs
  function build (line 65) | pub(crate) fn build<'a, T: Value, F: FnOnce(&mut raw::Local) -> bool>(
  type Value (line 92) | pub trait Value: ValueInternal {
    method to_string (line 93) | fn to_string<'cx, C: Context<'cx>>(&self, cx: &mut C) -> JsResult<'cx,...
    method as_value (line 100) | fn as_value<'cx, C: Context<'cx>>(&self, _: &mut C) -> Handle<'cx, JsV...
    method to_raw (line 107) | fn to_raw(&self) -> sys::Value {
    method from_raw (line 119) | unsafe fn from_raw<'cx, C: Context<'cx>>(cx: &C, value: sys::Value) ->...
  type JsValue (line 162) | pub struct JsValue(raw::Local);
    method upcast_internal (line 80) | fn upcast_internal(v: &T) -> JsValue {
    method new_internal (line 193) | pub(crate) fn new_internal<'a>(value: raw::Local) -> Handle<'a, JsValu...
  type Inner (line 167) | type Inner = raw::Local;
  method into_inner (line 169) | fn into_inner(self) -> Self::Inner {
  method name (line 175) | fn name() -> &'static str {
  method is_typeof (line 179) | fn is_typeof<Other: Value>(_cx: &mut Cx, _other: &Other) -> bool {
  method to_local (line 183) | fn to_local(&self) -> raw::Local {
  method from_local (line 187) | unsafe fn from_local(_env: Env, h: raw::Local) -> Self {
  type JsUndefined (line 220) | pub struct JsUndefined(raw::Local);
    method new (line 229) | pub fn new<'a, C: Context<'a>>(cx: &mut C) -> Handle<'a, JsUndefined> {
    method new_internal (line 233) | pub(crate) fn new_internal<'a>(env: Env) -> Handle<'a, JsUndefined> {
  type Inner (line 245) | type Inner = raw::Local;
  method into_inner (line 247) | fn into_inner(self) -> Self::Inner {
  method name (line 253) | fn name() -> &'static str {
  method is_typeof (line 257) | fn is_typeof<Other: Value>(cx: &mut Cx, other: &Other) -> bool {
  method to_local (line 261) | fn to_local(&self) -> raw::Local {
  method from_local (line 265) | unsafe fn from_local(_env: Env, h: raw::Local) -> Self {
  type JsNull (line 289) | pub struct JsNull(raw::Local);
    method new (line 298) | pub fn new<'a, C: Context<'a>>(cx: &mut C) -> Handle<'a, JsNull> {
    method new_internal (line 302) | pub(crate) fn new_internal<'a>(env: Env) -> Handle<'a, JsNull> {
  type Inner (line 314) | type Inner = raw::Local;
  method into_inner (line 316) | fn into_inner(self) -> Self::Inner {
  method name (line 322) | fn name() -> &'static str {
  method is_typeof (line 326) | fn is_typeof<Other: Value>(cx: &mut Cx, other: &Other) -> bool {
  method to_local (line 330) | fn to_local(&self) -> raw::Local {
  method from_local (line 334) | unsafe fn from_local(_env: Env, h: raw::Local) -> Self {
  type JsBoolean (line 359) | pub struct JsBoolean(raw::Local);
    method new (line 365) | pub fn new<'a, C: Context<'a>>(cx: &mut C, b: bool) -> Handle<'a, JsBo...
    method new_internal (line 369) | pub(crate) fn new_internal<'a>(env: Env, b: bool) -> Handle<'a, JsBool...
    method value (line 378) | pub fn value<'a, C: Context<'a>>(&self, cx: &mut C) -> bool {
  type Inner (line 387) | type Inner = raw::Local;
  method into_inner (line 389) | fn into_inner(self) -> Self::Inner {
  method name (line 395) | fn name() -> &'static str {
  method is_typeof (line 399) | fn is_typeof<Other: Value>(cx: &mut Cx, other: &Other) -> bool {
  method to_local (line 403) | fn to_local(&self) -> raw::Local {
  method from_local (line 407) | unsafe fn from_local(_env: Env, h: raw::Local) -> Self {
  type JsString (line 431) | pub struct JsString(raw::Local);
    method size (line 504) | pub fn size<'a, C: Context<'a>>(&self, cx: &mut C) -> usize {
    method size_utf16 (line 530) | pub fn size_utf16<'a, C: Context<'a>>(&self, cx: &mut C) -> usize {
    method value (line 552) | pub fn value<'a, C: Context<'a>>(&self, cx: &mut C) -> String {
    method to_utf16 (line 604) | pub fn to_utf16<'a, C: Context<'a>>(&self, cx: &mut C) -> Vec<u16> {
    method new (line 633) | pub fn new<'a, C: Context<'a>, S: AsRef<str>>(cx: &mut C, val: S) -> H...
    method try_new (line 659) | pub fn try_new<'a, C: Context<'a>, S: AsRef<str>>(cx: &mut C, val: S) ...
    method new_internal (line 667) | pub(crate) fn new_internal<'a>(env: Env, val: &str) -> Option<Handle<'...
  type StringOverflow (line 435) | pub struct StringOverflow(usize);
    method fmt (line 438) | fn fmt(&self, f: &mut fmt::Formatter) -> fmt::Result {
  type StringResult (line 444) | pub type StringResult<'a> = Result<Handle<'a, JsString>, StringOverflow>;
  function or_throw (line 447) | fn or_throw<'b, C: Context<'b>>(self, cx: &mut C) -> JsResult<'a, JsStri...
  type Inner (line 458) | type Inner = raw::Local;
  method into_inner (line 460) | fn into_inner(self) -> Self::Inner {
  method name (line 466) | fn name() -> &'static str {
  method is_typeof (line 470) | fn is_typeof<Other: Value>(cx: &mut Cx, other: &Other) -> bool {
  method to_local (line 474) | fn to_local(&self) -> raw::Local {
  method from_local (line 478) | unsafe fn from_local(_env: Env, h: raw::Local) -> Self {
  type JsNumber (line 704) | pub struct JsNumber(raw::Local);
    method new (line 710) | pub fn new<'a, C: Context<'a>, T: Into<f64>>(cx: &mut C, x: T) -> Hand...
    method new_internal (line 714) | pub(crate) fn new_internal<'a>(env: Env, v: f64) -> Handle<'a, JsNumbe...
    method value (line 723) | pub fn value<'a, C: Context<'a>>(&self, cx: &mut C) -> f64 {
  type Inner (line 732) | type Inner = raw::Local;
  method into_inner (line 734) | fn into_inner(self) -> Self::Inner {
  method name (line 740) | fn name() -> &'static str {
  method is_typeof (line 744) | fn is_typeof<Other: Value>(cx: &mut Cx, other: &Other) -> bool {
  method to_local (line 748) | fn to_local(&self) -> raw::Local {
  method from_local (line 752) | unsafe fn from_local(_env: Env, h: raw::Local) -> Self {
  type JsObject (line 781) | pub struct JsObject(raw::Local);
    method upcast_internal (line 86) | fn upcast_internal(v: &T) -> JsObject {
    method new (line 817) | pub fn new<'a, C: Context<'a>>(c: &mut C) -> Handle<'a, JsObject> {
    method new_internal (line 821) | pub(crate) fn new_internal<'a>(env: Env) -> Handle<'a, JsObject> {
    method build (line 825) | pub(crate) fn build<'a, F: FnOnce(&mut raw::Local)>(init: F) -> Handle...
  type Inner (line 786) | type Inner = raw::Local;
  method into_inner (line 788) | fn into_inner(self) -> Self::Inner {
  method name (line 794) | fn name() -> &'static str {
  method is_typeof (line 798) | fn is_typeof<Other: Value>(cx: &mut Cx, other: &Other) -> bool {
  method to_local (line 802) | fn to_local(&self) -> raw::Local {
  method from_local (line 806) | unsafe fn from_local(_env: Env, h: raw::Local) -> Self {
  type JsArray (line 858) | pub struct JsArray(raw::Local);
    method new (line 872) | pub fn new<'a, C: Context<'a>>(cx: &mut C, len: usize) -> Handle<'a, J...
    method new_internal (line 876) | pub(crate) fn new_internal<'a>(env: Env, len: usize) -> Handle<'a, JsA...
    method to_vec (line 889) | pub fn to_vec<'a, C: Context<'a>>(&self, cx: &mut C) -> NeonResult<Vec...
    method len_inner (line 903) | fn len_inner(&self, env: Env) -> u32 {
    method len (line 910) | pub fn len<'a, C: Context<'a>>(&self, cx: &mut C) -> u32 {
    method is_empty (line 916) | pub fn is_empty<'a, C: Context<'a>>(&self, cx: &mut C) -> bool {
  type Inner (line 924) | type Inner = raw::Local;
  method into_inner (line 926) | fn into_inner(self) -> Self::Inner {
  method name (line 932) | fn name() -> &'static str {
  method is_typeof (line 936) | fn is_typeof<Other: Value>(cx: &mut Cx, other: &Other) -> bool {
  method to_local (line 940) | fn to_local(&self) -> raw::Local {
  method from_local (line 944) | unsafe fn from_local(_env: Env, h: raw::Local) -> Self {
  type JsFunction (line 1024) | pub struct JsFunction {
    method new (line 1033) | pub fn new<'a, C, U>(
    method new (line 1048) | pub fn new<'a, C, F, V>(cx: &mut C, f: F) -> JsResult<'a, JsFunction>
    method with_name (line 1061) | pub fn with_name<'a, C, U>(
    method with_name (line 1075) | pub fn with_name<'a, C, F, V>(cx: &mut C, name: &str, f: F) -> JsResul...
    method new_internal (line 1084) | fn new_internal<'a, C, F, V>(cx: &mut C, f: F, name: &str) -> JsResult...
    method call (line 1126) | pub fn call<'a, 'b, C: Context<'a>, T, AS>(
    method exec (line 1142) | pub fn exec<'a, 'b, C: Context<'a>, T, AS>(
    method construct (line 1159) | pub fn construct<'a, 'b, C: Context<'a>, AS>(
    method bind (line 1190) | pub fn bind<'a, 'cx: 'a>(&self, cx: &'a mut Cx<'cx>) -> BindOptions<'a...
    method call_with (line 1204) | pub fn call_with<'a, C: Context<'a>>(&self, _cx: &C) -> CallOptions<'a> {
    method construct_with (line 1219) | pub fn construct_with<'a, C: Context<'a>>(&self, _cx: &C) -> Construct...
    method clone (line 1232) | unsafe fn clone(&self) -> Self {
  type Inner (line 1240) | type Inner = raw::Local;
  method into_inner (line 1242) | fn into_inner(self) -> Self::Inner {
  method name (line 1248) | fn name() -> &'static str {
  method is_typeof (line 1252) | fn is_typeof<Other: Value>(cx: &mut Cx, other: &Other) -> bool {
  method to_local (line 1256) | fn to_local(&self) -> raw::Local {
  method from_local (line 1260) | unsafe fn from_local(_env: Env, h: raw::Local) -> Self {
  type JsBigInt (line 1298) | pub struct JsBigInt(raw::Local);

FILE: crates/neon/src/types_impl/private.rs
  constant V8_ARGC_LIMIT (line 17) | const V8_ARGC_LIMIT: usize = 65535;
  function prepare_call (line 19) | pub(crate) unsafe fn prepare_call<'a, 'b, C: Context<'a>>(
  type ValueInternal (line 34) | pub trait ValueInternal: TransparentNoCopyWrapper + 'static {
    method name (line 35) | fn name() -> &'static str;
    method is_typeof (line 37) | fn is_typeof<Other: Value>(cx: &mut Cx, other: &Other) -> bool;
    method downcast (line 39) | fn downcast<Other: Value>(cx: &mut Cx, other: &Other) -> Option<Self> {
    method cast (line 49) | fn cast<'a, T: Value, F: FnOnce(raw::Local) -> T>(self, f: F) -> Handl...
    method to_local (line 53) | fn to_local(&self) -> raw::Local;
    method from_local (line 57) | unsafe fn from_local(env: Env, h: raw::Local) -> Self;
    method try_call (line 59) | unsafe fn try_call<'a, 'b, C: Context<'a>, T, AS>(
    method try_construct (line 91) | unsafe fn try_construct<'a, 'b, C: Context<'a>, AS>(
  function check_call_status (line 115) | unsafe fn check_call_status<'a, C: Context<'a>>(

FILE: crates/neon/src/types_impl/promise.rs
  constant BOUNDARY (line 42) | const BOUNDARY: FailureBoundary = FailureBoundary {
  type JsPromise (line 139) | pub struct JsPromise(raw::Local);
    method new (line 142) | pub(crate) fn new<'a, C: Context<'a>>(cx: &mut C) -> (Deferred, Handle...
    method resolve (line 158) | pub fn resolve<'a, C: Context<'a>, T: Value>(cx: &mut C, value: Handle...
    method reject (line 165) | pub fn reject<'a, C: Context<'a>, E: Value>(cx: &mut C, err: Handle<E>...
    method to_future (line 180) | pub fn to_future<'a, O, C, F>(&self, cx: &mut C, f: F) -> NeonResult<J...
  type Inner (line 246) | type Inner = raw::Local;
  method into_inner (line 248) | fn into_inner(self) -> Self::Inner {
  method name (line 254) | fn name() -> &'static str {
  method is_typeof (line 258) | fn is_typeof<Other: Value>(cx: &mut Cx, other: &Other) -> bool {
  method to_local (line 262) | fn to_local(&self) -> raw::Local {
  method from_local (line 266) | unsafe fn from_local(_env: Env, h: raw::Local) -> Self {
  type Deferred (line 287) | pub struct Deferred {
    method resolve (line 295) | pub fn resolve<'a, V, C>(self, cx: &mut C, value: Handle<V>)
    method reject (line 306) | pub fn reject<'a, V, C>(self, cx: &mut C, value: Handle<V>)
    method try_settle_with (line 325) | pub fn try_settle_with<V, F>(
    method settle_with (line 358) | pub fn settle_with<V, F>(self, channel: &Channel, complete: F) -> Join...
    method try_settle (line 374) | pub fn try_settle<V, T>(self, channel: &Channel, v: T) -> Result<JoinH...
    method settle (line 399) | pub fn settle<V, T>(self, channel: &Channel, v: T) -> JoinHandle<()>
    method try_catch_settle (line 407) | pub(crate) fn try_catch_settle<'a, C, V, F>(self, cx: C, f: F)
    method into_inner (line 425) | pub(crate) fn into_inner(mut self) -> sys::Deferred {
  type NodeApiDeferred (line 431) | pub(crate) struct NodeApiDeferred(sys::Deferred);
    method leaked (line 437) | pub(crate) unsafe fn leaked(self, env: raw::Env) {
  method drop (line 448) | fn drop(&mut self) {
  method drop (line 468) | fn drop(&mut self) {
  type JsFuture (line 558) | pub struct JsFuture<T> {
  type Output (line 566) | type Output = Result<T, JoinError>;
  method poll (line 568) | fn poll(mut self: Pin<&mut Self>, cx: &mut task::Context) -> Poll<Self::...

FILE: crates/neon/src/types_impl/utf8.rs
  constant SMALL_MAX (line 3) | const SMALL_MAX: usize = i32::MAX as usize;
  type SmallUtf8 (line 8) | pub struct SmallUtf8<'a> {
  function lower (line 13) | pub fn lower(&self) -> (*const u8, i32) {
  type Utf8 (line 20) | pub struct Utf8<'a> {
  function from (line 25) | fn from(s: &'a str) -> Self {
  function size (line 33) | pub fn size(&self) -> usize {
  function into_small (line 37) | pub fn into_small(self) -> Option<SmallUtf8<'a>> {
  function into_small_unwrap (line 47) | pub fn into_small_unwrap(self) -> SmallUtf8<'a> {
  function truncate (line 54) | pub fn truncate(self) -> SmallUtf8<'a> {

FILE: pkgs/cargo-cp-artifact/src/args.js
  class ParseError (line 3) | class ParseError extends Error {}
  constant NPM_ENV (line 5) | const NPM_ENV = "npm_package_name";
  constant EXPECTED_COMMAND (line 6) | const EXPECTED_COMMAND = [
  function validateArtifactType (line 15) | function validateArtifactType(artifactType) {
  function getArtifactName (line 32) | function getArtifactName({ artifactType, crateName }) {
  function getCrateNameFromEnv (line 36) | function getCrateNameFromEnv(env) {
  function parse (line 57) | function parse(argv, env) {

FILE: pkgs/cargo-cp-artifact/src/index.js
  function run (line 12) | function run(argv, env) {
  function processCargoBuildLine (line 66) | function processCargoBuildLine(options, copied, line) {
  function getOutputFiles (line 103) | function getOutputFiles(kind, name, artifacts) {
  function isNewer (line 121) | async function isNewer(filename, outputFile) {
  function copyArtifact (line 132) | async function copyArtifact(filename, outputFile) {
  function parseArgs (line 165) | function parseArgs(argv, env) {
  function quitError (line 177) | function quitError(msg) {

FILE: pkgs/create-neon/dev/expect.ts
  function splitLines (line 6) | function splitLines(s: string): string[] {
  function isCompleteLine (line 10) | function isCompleteLine(s: string): boolean {
  class LinesBuffer (line 14) | class LinesBuffer {
    method constructor (line 20) | constructor() {
    method add (line 24) | add(lines: string[]) {
    method find (line 38) | find(p: (s: string) => boolean): string[] | null {
  type Pattern (line 51) | interface Pattern {
  type QA (line 55) | type QA = { q: string; a: string };
  class ExpectLine (line 57) | class ExpectLine implements Pattern {
    method constructor (line 61) | constructor(optional: QA[], required: QA) {
    method expect (line 66) | async *expect(session: Session): AsyncGenerator<string[]> {
  class ExpectEOF (line 105) | class ExpectEOF implements Pattern {
    method constructor (line 108) | constructor(optional: QA[]) {
    method expect (line 113) | async *expect(session: Session): AsyncGenerator<string[]> {
  class Script (line 118) | class Script {
    method constructor (line 121) | constructor(src: Record<string, string>) {
    method run (line 147) | async *run(session: Session): AsyncGenerator<string[]> {
  class Session (line 156) | class Session {
    method constructor (line 161) | constructor(stdin: Writable, stdout: Readable) {
  function exit (line 168) | function exit(child: ChildProcess): Promise<number | null> {
  function expect (line 179) | async function expect(

FILE: pkgs/create-neon/src/bin/create-neon.ts
  constant OPTIONS (line 18) | const OPTIONS = [
  function parsePlatforms (line 82) | function parsePlatforms(
  function parseCI (line 107) | function parseCI(ci: string): CI | undefined {
  function parseCache (line 120) | function parseCache(

FILE: pkgs/create-neon/src/cache.ts
  type Cache (line 1) | interface Cache {

FILE: pkgs/create-neon/src/cache/npm.ts
  class NPM (line 3) | class NPM implements Cache {
    method constructor (line 9) | constructor(org: string, prefix: string) {

FILE: pkgs/create-neon/src/ci.ts
  type CI (line 1) | interface CI {

FILE: pkgs/create-neon/src/ci/github.ts
  constant TEMPLATES (line 5) | const TEMPLATES: Record<string, string> = {
  function githubDelegate (line 13) | function githubDelegate(
  class GitHub (line 20) | class GitHub implements CI {
    method constructor (line 21) | constructor() {}
    method templates (line 25) | templates(): Record<string, string> {
    method setup (line 29) | setup(): void {
    method scripts (line 33) | scripts(): Record<string, string> {

FILE: pkgs/create-neon/src/create/app.ts
  class AppCreator (line 3) | class AppCreator extends Creator {
    method constructor (line 4) | constructor(options: ProjectOptions) {
    method scripts (line 8) | scripts(): Record<string, string> {

FILE: pkgs/create-neon/src/create/creator.ts
  type Lang (line 12) | enum Lang {
  type ModuleType (line 18) | enum ModuleType {
  type LibraryOptions (line 23) | type LibraryOptions = {
  type ProjectOptions (line 31) | type ProjectOptions = {
  function stripNpmNamespace (line 43) | function stripNpmNamespace(pkg: string): string {
  method for (line 52) | static async for(options: ProjectOptions): Promise<Creator> {
  method constructor (line 62) | constructor(options: ProjectOptions) {
  method create (line 66) | async create(cx: Context): Promise<void> {
  method createNeonBoilerplate (line 137) | async createNeonBoilerplate(cx: Context): Promise<void> {
  method prepare (line 146) | async prepare(cx: Context): Promise<void> {
  method templates (line 155) | templates(_pkg: string): Record<string, string> {
  method scripts (line 164) | scripts(): Record<string, string> {
  method baseTemplate (line 168) | baseTemplate(): string {

FILE: pkgs/create-neon/src/create/lib.ts
  constant TS_TEMPLATES (line 12) | const TS_TEMPLATES: Record<string, string> = {
  class LibCreator (line 19) | class LibCreator extends Creator {
    method constructor (line 22) | constructor(options: ProjectOptions) {
    method templates (line 30) | templates(pkg: string): Record<string, string> {
    method createNeonBoilerplate (line 42) | async createNeonBoilerplate(cx: Context): Promise<void> {
    method createTSBoilerplate (line 56) | async createTSBoilerplate(cx: Context): Promise<void> {
    method createCIBoilerplate (line 63) | async createCIBoilerplate(cx: Context): Promise<void> {
    method addPlatforms (line 71) | async addPlatforms(cx: Context): Promise<void> {
    method scripts (line 93) | scripts(): Record<string, string> {
    method baseTemplate (line 116) | baseTemplate(): string {

FILE: pkgs/create-neon/src/die.ts
  function deleteNeonDir (line 3) | function deleteNeonDir(dir: string): Promise<void> {
  function die (line 7) | async function die(

FILE: pkgs/create-neon/src/expand/context.ts
  type ManifestData (line 4) | type ManifestData = {
  type CrateData (line 12) | type CrateData = ManifestData & {
  class Context (line 18) | class Context {
    method constructor (line 24) | constructor(options: ProjectOptions) {

FILE: pkgs/create-neon/src/expand/index.ts
  constant TEMPLATES_DIR (line 7) | const TEMPLATES_DIR = new URL(
  constant COMPARISON_HELPERS (line 12) | const COMPARISON_HELPERS = helpers("comparison");
  function expand (line 16) | async function expand(source: string, cx: Context): Promise<string> {
  function expandTo (line 22) | async function expandTo(source: string, target: string, cx: Context) {

FILE: pkgs/create-neon/src/expand/versions.ts
  type Versions (line 14) | type Versions = {
  constant KEYS (line 40) | const KEYS = [
  function assertIsVersions (line 51) | function assertIsVersions(data: unknown): asserts data is Versions {
  function load (line 64) | function load(): Versions {
  constant VERSIONS (line 70) | const VERSIONS: Versions = load();

FILE: pkgs/create-neon/src/fs.ts
  function assertCanMkdir (line 5) | async function assertCanMkdir(dir: string) {
  function mktemp (line 12) | async function mktemp(): Promise<string> {

FILE: pkgs/create-neon/src/index.ts
  constant CREATE_NEON_PRELUDE (line 15) | const CREATE_NEON_PRELUDE: string = `
  function askProjectType (line 27) | async function askProjectType(options: ProjectOptions) {
  function createNeon (line 102) | async function createNeon(options: ProjectOptions): Promise<void> {

FILE: pkgs/create-neon/src/print.ts
  function pink (line 4) | function pink(text: string): string {
  function green (line 8) | function green(text: string): string {
  function blue (line 12) | function blue(text: string): string {
  function yellow (line 16) | function yellow(text: string): string {
  function bold (line 20) | function bold(text: string): string {
  function mainUsage (line 24) | function mainUsage(): string {
  function printMainUsage (line 91) | function printMainUsage() {
  function printErrorWithUsage (line 95) | function printErrorWithUsage(e: any) {
  function printError (line 101) | function printError(e: any) {

FILE: pkgs/create-neon/src/shell.ts
  function readChunks (line 8) | function readChunks(input: Readable): Readable {
  type NpmInitExit (line 25) | type NpmInitExit = {
  class NpmInitProcess (line 35) | class NpmInitProcess {
    method constructor (line 39) | constructor(interactive: boolean, args: string[], cwd: string, tmp: st...
    method exit (line 49) | exit(): Promise<NpmInitExit> {
    method filterStdout (line 60) | async filterStdout(opts: { interactive: boolean }) {
  constant NPM_INIT_KEYS (line 94) | const NPM_INIT_KEYS = [
  function sort (line 104) | function sort(json: any): any {
  function npmInit (line 114) | async function npmInit(
  type Parser (line 138) | type Parser<T> = (v: string) => T;
  function oneOf (line 140) | function oneOf<T extends {}>(opts: T): Parser<T[keyof T]> {
  type Question (line 151) | interface Question<T> {
  class Dialog (line 158) | class Dialog {
    method constructor (line 161) | constructor() {
    method rl (line 168) | private rl(): readline.Interface {
    method end (line 175) | end() {
    method ask (line 180) | async ask<T>(opts: Question<T>): Promise<T> {

FILE: pkgs/create-neon/test/create-neon.ts
  constant NODE (line 10) | const NODE: string = process.execPath;
  constant CREATE_NEON (line 11) | const CREATE_NEON = fileURLToPath(
  constant PROJECT (line 35) | const PROJECT = "create-neon-test-project";
  constant NAMESPACED_PROJECT (line 36) | const NAMESPACED_PROJECT = "@dherman/create-neon-test-project";

FILE: test/electron/main.js
  function createWindow (line 5) | function createWindow() {

FILE: test/electron/src/lib.rs
  function hello (line 3) | fn hello(mut cx: FunctionContext) -> JsResult<JsString> {
  function main (line 8) | fn main(mut cx: ModuleContext) -> NeonResult<()> {

FILE: test/napi/lib/boxed.js
  class Person (line 5) | class Person {
    method constructor (line 6) | constructor(name) {
    method greet (line 10) | greet() {
  class RefPerson (line 15) | class RefPerson {
    method constructor (line 16) | constructor(name) {
    method greet (line 20) | greet() {
    method setName (line 24) | setName(name) {
    method fail (line 30) | fail() {

FILE: test/napi/lib/class.js
  class LoudMessage (line 122) | class LoudMessage extends Message {
    method shout (line 123) | shout() {

FILE: test/napi/lib/export.js
  function globals (line 11) | function globals() {
  function functions (line 28) | function functions() {
  function classes (line 123) | function classes() {

FILE: test/napi/lib/functions.js
  constant SLOPPY (line 8) | const SLOPPY = Function("return this;");
  function isStrict (line 10) | function isStrict(f) {
  function MyClass (line 86) | function MyClass(number, string) {

FILE: test/napi/lib/futures.js
  function assertRejects (line 5) | async function assertRejects(f, ...args) {

FILE: test/napi/lib/objects.js
  method nullary (line 105) | nullary() {
  method unary (line 108) | unary(x) {
  method [sym] (line 120) | [sym]() {
  method setName (line 145) | setName(name) {
  method toString (line 148) | toString() {

FILE: test/napi/lib/typedarrays.js
  constant DETACH_WORKER (line 17) | const DETACH_WORKER = new Worker(__filename);
  function detach (line 23) | function detach(buffer) {
  function testDetach (line 442) | function testDetach(

FILE: test/napi/lib/types.js
  class SubclassError (line 43) | class SubclassError extends Error {}

FILE: test/napi/src/js/arrays.rs
  function return_js_array (line 3) | pub fn return_js_array(mut cx: FunctionContext) -> JsResult<JsArray> {
  function return_js_array_with_number (line 7) | pub fn return_js_array_with_number(mut cx: FunctionContext) -> JsResult<...
  function return_js_array_with_string (line 14) | pub fn return_js_array_with_string(mut cx: FunctionContext) -> JsResult<...
  function read_js_array (line 21) | pub fn read_js_array(mut cx: FunctionContext) -> JsResult<JsValue> {

FILE: test/napi/src/js/bigint.rs
  function panic_catch (line 16) | fn panic_catch<'cx, F, C>(cx: &mut C, f: F) -> JsResult<'cx, JsFunction>
  function export (line 37) | fn export<F>(cx: &mut FunctionContext, o: &JsObject, f: F) -> NeonResult...
  function export_lossy (line 49) | fn export_lossy<T, F>(cx: &mut FunctionContext, o: &JsObject, f: F) -> N...
  function eval (line 68) | fn eval<'cx, C>(cx: &mut C, script: &str) -> JsResult<'cx, JsValue>
  function strict_eq (line 78) | fn strict_eq<'cx, L, R, C>(l: Handle<'cx, L>, r: Handle<'cx, R>, cx: &mu...
  function assert_eq (line 95) | fn assert_eq<'cx, L, R, C>(l: L, r: R, cx: &mut C) -> NeonResult<()>
  function bigint (line 109) | fn bigint<'cx, C>(cx: &mut C, n: &str) -> JsResult<'cx, JsBigInt>
  function to_bigint (line 136) | fn to_bigint<'cx, V, C>(b: Handle<V>, cx: &mut C) -> NeonResult<BigInt>
  function test_from_u64 (line 150) | fn test_from_u64(cx: &mut FunctionContext) -> NeonResult<()> {
  function test_from_i64 (line 162) | fn test_from_i64(cx: &mut FunctionContext) -> NeonResult<()> {
  function test_from_u128 (line 182) | fn test_from_u128(cx: &mut FunctionContext) -> NeonResult<()> {
  function test_from_i128 (line 201) | fn test_from_i128(cx: &mut FunctionContext) -> NeonResult<()> {
  function test_from_digits_le (line 233) | fn test_from_digits_le(cx: &mut FunctionContext) -> NeonResult<()> {
  function test_to_u64 (line 265) | fn test_to_u64(cx: &mut FunctionContext) -> NeonResult<()> {
  function test_to_i64 (line 278) | fn test_to_i64(cx: &mut FunctionContext) -> NeonResult<()> {
  function test_to_u128 (line 302) | fn test_to_u128(cx: &mut FunctionContext) -> NeonResult<()> {
  function test_to_i128 (line 330) | fn test_to_i128(cx: &mut FunctionContext) -> NeonResult<()> {
  function test_to_digits_le (line 362) | fn test_to_digits_le(cx: &mut FunctionContext) -> NeonResult<()> {
  function test_very_large_number (line 408) | fn test_very_large_number(cx: &mut FunctionContext) -> NeonResult<()> {
  function test_i64_out_of_range (line 436) | fn test_i64_out_of_range(cx: &mut FunctionContext) -> NeonResult<Result<...
  function test_u64_out_of_range (line 440) | fn test_u64_out_of_range(cx: &mut FunctionContext) -> NeonResult<Result<...
  function test_i128_extra_digits (line 444) | fn test_i128_extra_digits(cx: &mut FunctionContext) -> NeonResult<Result...
  function test_i128_overflow (line 452) | fn test_i128_overflow(cx: &mut FunctionContext) -> NeonResult<Result<i12...
  function test_i128_underflow (line 460) | fn test_i128_underflow(cx: &mut FunctionContext) -> NeonResult<Result<i1...
  function test_u128_overflow (line 468) | fn test_u128_overflow(cx: &mut FunctionContext) -> NeonResult<Result<i12...
  function test_u128_underflow (line 476) | fn test_u128_underflow(cx: &mut FunctionContext) -> NeonResult<Result<u1...
  function bigint_suite (line 486) | pub fn bigint_suite(mut cx: FunctionContext) -> JsResult<JsObject> {

FILE: test/napi/src/js/boxed.rs
  type Person (line 5) | pub struct Person {
    method new (line 12) | fn new(name: impl ToString) -> Self {
    method greet (line 18) | fn greet(&self) -> String {
    method set_name (line 22) | fn set_name(&mut self, name: impl ToString) {
  function person_new (line 27) | pub fn person_new(mut cx: FunctionContext) -> JsResult<JsBox<Person>> {
  function person_greet (line 34) | pub fn person_greet(mut cx: FunctionContext) -> JsResult<JsString> {
  function ref_person_new (line 41) | pub fn ref_person_new(mut cx: FunctionContext) -> JsResult<JsValue> {
  function ref_person_greet (line 48) | pub fn ref_person_greet(mut cx: FunctionContext) -> JsResult<JsString> {
  function ref_person_set_name (line 55) | pub fn ref_person_set_name(mut cx: FunctionContext) -> JsResult<JsUndefi...
  function ref_person_fail (line 64) | pub fn ref_person_fail(mut cx: FunctionContext) -> JsResult<JsUndefined> {
  function external_unit (line 72) | pub fn external_unit(mut cx: FunctionContext) -> JsResult<JsBox<()>> {
  function create_boxed_string (line 77) | fn create_boxed_string(s: String) -> Boxed<String> {
  function boxed_string_concat (line 82) | fn boxed_string_concat(Boxed(this): Boxed<String>, rhs: String) -> String {
  function boxed_string_repeat (line 88) | fn boxed_string_repeat(_cx: &mut FunctionContext, this: Boxed<String>, n...

FILE: test/napi/src/js/class.rs
  function wrap_string (line 6) | fn wrap_string(cx: &mut Cx, o: Handle<JsObject>, s: String) -> NeonResul...
  function unwrap_string (line 11) | fn unwrap_string(cx: &mut Cx, o: Handle<JsObject>) -> NeonResult<String> {
  type Message (line 18) | pub struct Message {
    method new (line 24) | pub fn new(value: String) -> Self {
    method read (line 28) | pub fn read(&self) -> &str {
    method concat (line 32) | pub fn concat(&self, other: &Self) -> Self {
    method append (line 38) | pub fn append(&mut self, suffix: String) {
    method finalize (line 42) | pub fn finalize<'a, C: Context<'a>>(self, _cx: &mut C) {
  type Point (line 48) | pub struct Point {
    constant ORIGIN_X (line 56) | const ORIGIN_X: u32 = 0;
    constant ORIGIN_Y (line 57) | const ORIGIN_Y: u32 = 0;
    constant MAX_COORD (line 61) | const MAX_COORD: u32 = 1000;
    constant DEFAULT_MESSAGE (line 65) | const DEFAULT_MESSAGE: &'static [&'static str] = &["hello", "point"];
    constant COMPUTED_VALUE (line 68) | const COMPUTED_VALUE: u32 = 10 + 20 + 12;
    constant SIZE_OF_F64 (line 69) | const SIZE_OF_F64: u32 = std::mem::size_of::<f64>() as u32;
    constant STRING_LENGTH (line 70) | const STRING_LENGTH: u32 = "complex".len() as u32;
    constant SELF_SIZE (line 73) | const SELF_SIZE: u32 = std::mem::size_of::<Self>() as u32;
    constant POINT_ALIGNMENT (line 74) | const POINT_ALIGNMENT: u32 = std::mem::align_of::<Point>() as u32;
    constant IS_2D (line 77) | const IS_2D: bool = true;
    constant MAX_DIMENSION (line 80) | const MAX_DIMENSION: u32 = if std::mem::size_of::<u32>() == 4 {
    constant COORDINATE_BYTES (line 87) | const COORDINATE_BYTES: u32 = match std::mem::size_of::<u32>() {
    constant DOUBLE_100_SQUARED (line 94) | const DOUBLE_100_SQUARED: u32 = 100_u32.pow(2) * 2;
    constant SPECIAL_CHARS (line 98) | const SPECIAL_CHARS: &'static str = "Hello\nWorld\t\"quoted\"\r\n";
    constant NEGATIVE_OFFSET (line 101) | const NEGATIVE_OFFSET: i32 = -42;
    constant MAX_SAFE_INTEGER_APPROX (line 104) | const MAX_SAFE_INTEGER_APPROX: u32 = 2147483647;
    constant _PRIVATE_CONST (line 107) | const _PRIVATE_CONST: u32 = 999;
    method new (line 109) | pub fn new(x: u32, y: u32) -> Self {
    method x (line 113) | pub fn x(&self) -> u32 {
    method y (line 117) | pub fn y(&self) -> u32 {
    method distance (line 121) | pub fn distance(&self, other: &Self) -> f64 {
    method midpoint (line 127) | pub fn midpoint(&self, other: &Self) -> Self {
    method swap_coords (line 134) | pub fn swap_coords(&mut self, other: &mut Self) {
    method move_by (line 139) | pub fn move_by(&mut self, dx: u32, dy: u32) {
    method set_x (line 144) | pub fn set_x(&mut self, x: u32) {
    method set_y (line 148) | pub fn set_y(&mut self, y: u32) {
  type StringBuffer (line 154) | pub struct StringBuffer {
    method push (line 160) | pub fn push(&mut self, s: String) {
    method to_string (line 165) | pub fn to_string(&self) -> String {
    method contains (line 170) | pub fn contains(&self, s: String) -> bool {
    method trim_start (line 175) | pub fn trim_start(&self) -> String {
    method trim_end (line 179) | pub fn trim_end(&self) -> String {
  type AsyncClass (line 186) | pub struct AsyncClass {
    constant DEFAULT_TIMEOUT (line 193) | const DEFAULT_TIMEOUT: u32 = 5000;
    constant VERSION_NUMBERS (line 197) | const VERSION_NUMBERS: &'static [u32] = &[1, 0, 0];
    method new (line 199) | pub fn new(value: String) -> Self {
    method async_method (line 209) | pub async fn async_method(self, suffix: String) -> String {
    method heavy_computation (line 216) | pub fn heavy_computation(self) -> u32 {
    method sync_method (line 226) | pub fn sync_method(&self) -> String {
    method json_method (line 232) | pub fn json_method(&self, data: Vec<String>) -> HashMap<String, String> {
    method explicit_async_method (line 245) | pub fn explicit_async_method(&self, multiplier: i32) -> impl Future<Ou...
    method explicit_async_clone (line 258) | pub fn explicit_async_clone(&self, suffix: String) -> impl Future<Outp...
    method method_with_context (line 266) | pub fn method_with_context<'a>(
    method method_with_explicit_context (line 277) | pub fn method_with_explicit_context(&self, _ctx: &mut Cx, suffix: Stri...
    method task_with_channel (line 283) | pub fn task_with_channel(self, _ch: Channel, multiplier: i32) -> String {
    method async_fn_with_channel (line 289) | pub async fn async_fn_with_channel(self, _ch: Channel, suffix: String)...
    method method_with_this (line 296) | pub fn method_with_this(&self, this: Handle<JsObject>, data: String) -...
    method method_with_explicit_this (line 306) | pub fn method_with_explicit_this(&self, _js_obj: Handle<JsObject>, suf...
    method method_with_context_and_this (line 312) | pub fn method_with_context_and_this<'a>(
    method simple_method (line 323) | pub fn simple_method(&self, x: i32) -> i32 {
    method json_method_perf (line 328) | pub fn json_method_perf(&self, data: Vec<i32>) -> Vec<i32> {
    method context_method_perf (line 332) | pub fn context_method_perf(&self, _cx: &mut FunctionContext, x: i32) -...
    method explicit_async_json_method (line 338) | pub fn explicit_async_json_method(
    method async_json_method (line 350) | pub async fn async_json_method(self, data: Vec<i32>) -> Vec<i32> {
  function create_point_from_rust (line 357) | pub fn create_point_from_rust(x: u32, y: u32) -> Point {
  function create_point_origin (line 363) | pub fn create_point_origin() -> Point {
  function double_point_coords (line 369) | pub fn double_point_coords(point: Point) -> Point {
  type FallibleCounter (line 375) | pub struct FallibleCounter {
    method new (line 381) | pub fn new(value: u32) -> Result<Self, String> {
    method get (line 389) | pub fn get(&self) -> u32 {
    method increment (line 393) | pub fn increment(&mut self) {
  type ContextCounter (line 400) | pub struct ContextCounter {
    method new (line 409) | pub fn new(_cx: &mut AlsoCx, value: u32) -> Self {
    method get (line 415) | pub fn get(&self) -> u32 {
  type AlsoCx (line 404) | type AlsoCx<'cx> = Cx<'cx>;
  type JsonConfig (line 422) | pub struct JsonConfig {
    method new (line 431) | pub fn new(config: JsonConfig) -> Self {
    method name (line 435) | pub fn name(&self) -> String {
    method count (line 439) | pub fn count(&self) -> u32 {
    method enabled (line 443) | pub fn enabled(&self) -> bool {
  type ValidatedConfig (line 450) | pub struct ValidatedConfig {
    method new (line 458) | pub fn new(_cx: &mut Cx, config: ValidatedConfig) -> Result<Self, Stri...
    method name (line 469) | pub fn name(&self) -> String {
    method count (line 473) | pub fn count(&self) -> u32 {
  type Secret (line 478) | pub struct Secret {
    method new (line 484) | pub fn new(cx: &mut Cx, init: Handle<JsValue>) -> NeonResult<Self> {
    method reveal (line 500) | pub fn reveal(&self) -> String {
  type Argv (line 505) | pub struct Argv {
    method new (line 512) | pub fn new(cx: &mut Cx, args: Option<Vec<String>>) -> NeonResult<Self> {
    method len (line 527) | pub fn len(&self) -> u32 {
    method get (line 531) | pub fn get(&self, index: u32) -> Option<String> {
  constant CAROUSEL_MESSAGES (line 536) | const CAROUSEL_MESSAGES: [&str; 5] = [
  type Carousel (line 544) | pub struct Carousel {
    method new (line 550) | pub fn new() -> Self {
    method next (line 554) | pub fn next(&mut self) -> String {
  type Expando (line 562) | pub struct Expando;
    method new (line 566) | pub fn new(cx: &mut FunctionContext) -> NeonResult<Self> {
    method expando (line 572) | pub fn expando(self, cx: &mut FunctionContext) -> NeonResult<i32> {

FILE: test/napi/src/js/coercions.rs
  function to_string (line 3) | pub fn to_string(mut cx: FunctionContext) -> JsResult<JsString> {

FILE: test/napi/src/js/container.rs
  function create_string_ref_cell (line 10) | fn create_string_ref_cell(s: String) -> RefCell<String> {
  function read_string_ref_cell (line 15) | fn read_string_ref_cell(s: &RefCell<String>) -> String {
  function write_string_ref_cell (line 20) | fn write_string_ref_cell(s: &RefCell<String>, value: String) {
  function string_ref_cell_concat (line 25) | fn string_ref_cell_concat(lhs: &RefCell<String>, rhs: String) -> String {
  function string_ref_concat (line 30) | fn string_ref_concat(lhs: Ref<String>, rhs: String) -> String {
  function write_string_ref (line 35) | fn write_string_ref(mut s: RefMut<String>, value: String) {
  function borrow_and_then (line 40) | fn borrow_and_then<'cx>(
  function borrow_mut_and_then (line 51) | fn borrow_mut_and_then<'cx>(
  function create_string_rc (line 63) | fn create_string_rc(s: String) -> Rc<String> {
  function read_string_rc (line 68) | fn read_string_rc(s: Rc<String>) -> String {
  function create_string_arc (line 73) | fn create_string_arc(s: String) -> Arc<String> {
  function read_string_arc (line 78) | fn read_string_arc(s: Arc<String>) -> String {

FILE: test/napi/src/js/date.rs
  function create_date (line 3) | pub fn create_date(mut cx: FunctionContext) -> JsResult<JsDate> {
  function create_date_from_value (line 8) | pub fn create_date_from_value(mut cx: FunctionContext) -> JsResult<JsDat...
  function check_date_is_valid (line 14) | pub fn check_date_is_valid(mut cx: FunctionContext) -> JsResult<JsBoolea...
  function try_new_date (line 21) | pub fn try_new_date(mut cx: FunctionContext) -> JsResult<JsUndefined> {
  function try_new_lossy_date (line 29) | pub fn try_new_lossy_date(mut cx: FunctionContext) -> JsResult<JsUndefin...
  function nan_dates (line 43) | pub fn nan_dates(mut cx: FunctionContext) -> JsResult<JsUndefined> {
  function check_date_is_invalid (line 55) | pub fn check_date_is_invalid(mut cx: FunctionContext) -> JsResult<JsBool...
  function create_and_get_invalid_date (line 63) | pub fn create_and_get_invalid_date(mut cx: FunctionContext) -> JsResult<...
  function get_date_value (line 89) | pub fn get_date_value(mut cx: FunctionContext) -> JsResult<JsNumber> {

FILE: test/napi/src/js/errors.rs
  function new_error (line 3) | pub fn new_error(mut cx: FunctionContext) -> JsResult<JsError> {
  function new_type_error (line 9) | pub fn new_type_error(mut cx: FunctionContext) -> JsResult<JsError> {
  function new_range_error (line 15) | pub fn new_range_error(mut cx: FunctionContext) -> JsResult<JsError> {
  function throw_error (line 21) | pub fn throw_error(mut cx: FunctionContext) -> JsResult<JsUndefined> {
  function downcast_error (line 27) | pub fn downcast_error(mut cx: FunctionContext) -> JsResult<JsString> {

FILE: test/napi/src/js/export.rs
  constant NUMBER (line 9) | const NUMBER: u8 = 42;
  function no_args_or_return (line 27) | fn no_args_or_return() {}
  function simple_add (line 30) | fn simple_add(a: f64, b: f64) -> f64 {
  function rs_renamed_add (line 35) | fn rs_renamed_add(a: f64, b: f64) -> f64 {
  function add_task (line 40) | fn add_task(a: f64, b: f64) -> f64 {
  function rs_renamed_add_task (line 45) | fn rs_renamed_add_task(a: f64, b: f64) -> f64 {
  function json_sort (line 50) | fn json_sort(mut items: Vec<String>) -> Vec<String> {
  function rs_renamed_json_sort (line 56) | fn rs_renamed_json_sort(items: Vec<String>) -> Vec<String> {
  function json_sort_task (line 61) | fn json_sort_task(items: Vec<String>) -> Vec<String> {
  function rs_renamed_json_sort_task (line 66) | fn rs_renamed_json_sort_task(items: Vec<String>) -> Vec<String> {
  function concat_with_cx_and_handle (line 71) | fn concat_with_cx_and_handle<'cx>(
  function fail_with_throw (line 82) | fn fail_with_throw(msg: String) -> Result<(), Error> {
  function sleep_task (line 94) | fn sleep_task(ms: f64) {
  function number_with_cx (line 101) | fn number_with_cx<'cx>(cx: &mut Cx<'cx>, n: f64) -> Handle<'cx, JsNumber> {
  function simple_self (line 106) | fn simple_self(this: Handle<JsObject>) -> Handle<JsObject> {
  function boxed_self (line 111) | fn boxed_self(Boxed(this): Boxed<String>) -> String {
  function boxed_string (line 116) | fn boxed_string(s: String) -> Boxed<String> {
  function add_i32 (line 121) | fn add_i32(a: i32, b: i32) -> i32 {
  function add_u32 (line 126) | fn add_u32(a: u32, b: u32) -> u32 {
  function to_i32 (line 131) | fn to_i32(n: i32) -> i32 {
  function to_u32 (line 136) | fn to_u32(n: u32) -> u32 {
  type ExportedPoint (line 142) | pub struct ExportedPoint {
    constant ORIGIN_X (line 149) | const ORIGIN_X: f64 = 0.0;
    constant ORIGIN_Y (line 150) | const ORIGIN_Y: f64 = 0.0;
    method new (line 152) | pub fn new(x: f64, y: f64) -> Self {
    method x (line 156) | pub fn x(&self) -> f64 {
    method y (line 160) | pub fn y(&self) -> f64 {
    method distance (line 164) | pub fn distance(&self, other: Self) -> f64 {
  type CustomNamedClass (line 173) | pub struct CustomNamedClass {
    method new (line 179) | pub fn new(value: String) -> Self {
    method get_value (line 183) | pub fn get_value(&self) -> String {
  type Case2Class (line 190) | pub struct Case2Class {
    method new (line 196) | pub fn new(message: String) -> Self {
    method get_message (line 200) | pub fn get_message(&self) -> String {
  type Case3Class (line 207) | pub struct Case3Class {
    method new (line 213) | pub fn new(data: i32) -> Self {
    method get_data (line 217) | pub fn get_data(&self) -> i32 {
  function export_async_json_test (line 224) | pub async fn export_async_json_test(data: Vec<i32>) -> Vec<i32> {

FILE: test/napi/src/js/extract.rs
  function extract_values (line 5) | pub fn extract_values(mut cx: FunctionContext) -> JsResult<JsArray> {
  function extract_buffer_sum (line 60) | pub fn extract_buffer_sum(mut cx: FunctionContext) -> JsResult<JsNumber> {
  function extract_json_sum (line 130) | pub fn extract_json_sum(mut cx: FunctionContext) -> JsResult<JsNumber> {
  function extract_single_add_one (line 136) | pub fn extract_single_add_one(mut cx: FunctionContext) -> JsResult<JsNum...
  function extract_json_option (line 143) | pub fn extract_json_option(maybe_x: Option<f64>) -> Option<f64> {
  function extract_either (line 148) | pub fn extract_either(either: Either<String, f64>) -> String {
  function buffer_concat (line 157) | pub fn buffer_concat(mut a: Vec<u8>, Uint8Array(b): Uint8Array<Vec<u8>>)...
  function string_to_buf (line 164) | pub fn string_to_buf(s: String) -> Uint8Array<String> {
  function sleep_with_js (line 171) | fn sleep_with_js(n: f64) -> impl for<'cx> TryIntoJs<'cx> {
  function sleep_with_js_sync (line 181) | fn sleep_with_js_sync(n: f64) -> impl for<'cx> TryIntoJs<'cx> {
  function sleep_with (line 187) | fn sleep_with(n: f64) -> impl for<'cx> TryIntoJs<'cx> {
  function sleep_with_sync (line 197) | fn sleep_with_sync(n: f64) -> impl for<'cx> TryIntoJs<'cx> {
  function extract_array_vec (line 202) | fn extract_array_vec(Array(arr): Array<Vec<f64>>) -> Array<Vec<f64>> {
  function extract_array_double (line 207) | fn extract_array_double(Array(arr): Array<Vec<f64>>) -> Array<impl Itera...
  function extract_array_dedupe (line 212) | fn extract_array_dedupe(set: Array<HashSet<String>>) -> Array<HashSet<St...

FILE: test/napi/src/js/functions.rs
  function add1 (line 3) | fn add1(mut cx: FunctionContext) -> JsResult<JsNumber> {
  function return_js_function (line 8) | pub fn return_js_function(mut cx: FunctionContext) -> JsResult<JsFunctio...
  function call_js_function (line 12) | pub fn call_js_function(mut cx: FunctionContext) -> JsResult<JsNumber> {
  function call_js_function_idiomatically (line 21) | pub fn call_js_function_idiomatically(mut cx: FunctionContext) -> JsResu...
  function call_js_function_with_bind (line 29) | pub fn call_js_function_with_bind(mut cx: FunctionContext) -> JsResult<J...
  function call_js_function_with_bind_and_args_with (line 40) | pub fn call_js_function_with_bind_and_args_with(mut cx: FunctionContext)...
  function call_js_function_with_bind_and_args_and_with (line 49) | pub fn call_js_function_with_bind_and_args_and_with(mut cx: FunctionCont...
  function call_parse_int_with_bind (line 60) | pub fn call_parse_int_with_bind(mut cx: FunctionContext) -> JsResult<JsN...
  function call_js_function_with_bind_and_exec (line 66) | pub fn call_js_function_with_bind_and_exec(mut cx: FunctionContext) -> J...
  function call_js_constructor_with_bind (line 71) | pub fn call_js_constructor_with_bind(mut cx: FunctionContext) -> JsResul...
  function bind_js_function_to_object (line 78) | pub fn bind_js_function_to_object(mut cx: FunctionContext) -> JsResult<J...
  function bind_js_function_to_number (line 85) | pub fn bind_js_function_to_number(mut cx: FunctionContext) -> JsResult<J...
  function get_math_max (line 90) | fn get_math_max<'a>(cx: &mut FunctionContext<'a>) -> JsResult<'a, JsFunc...
  function call_js_function_with_zero_args (line 96) | pub fn call_js_function_with_zero_args(mut cx: FunctionContext) -> JsRes...
  function call_js_function_with_one_arg (line 100) | pub fn call_js_function_with_one_arg(mut cx: FunctionContext) -> JsResul...
  function call_js_function_with_two_args (line 107) | pub fn call_js_function_with_two_args(mut cx: FunctionContext) -> JsResu...
  function call_js_function_with_three_args (line 115) | pub fn call_js_function_with_three_args(mut cx: FunctionContext) -> JsRe...
  function call_js_function_with_four_args (line 124) | pub fn call_js_function_with_four_args(mut cx: FunctionContext) -> JsRes...
  function call_js_function_with_custom_this (line 134) | pub fn call_js_function_with_custom_this(mut cx: FunctionContext) -> JsR...
  function call_js_function_with_implicit_this (line 144) | pub fn call_js_function_with_implicit_this(mut cx: FunctionContext) -> J...
  function exec_js_function_with_implicit_this (line 151) | pub fn exec_js_function_with_implicit_this(mut cx: FunctionContext) -> J...
  function call_js_function_with_heterogeneous_tuple (line 159) | pub fn call_js_function_with_heterogeneous_tuple(mut cx: FunctionContext...
  function construct_js_function (line 166) | pub fn construct_js_function(mut cx: FunctionContext) -> JsResult<JsNumb...
  function construct_js_function_idiomatically (line 178) | pub fn construct_js_function_idiomatically(mut cx: FunctionContext) -> J...
  function construct_js_function_with_overloaded_result (line 191) | pub fn construct_js_function_with_overloaded_result(mut cx: FunctionCont...
  function check_string_and_number (line 200) | pub fn check_string_and_number(mut cx: FunctionContext) -> JsResult<JsUn...
  function panic (line 206) | pub fn panic(_: FunctionContext) -> JsResult<JsUndefined> {
  function panic_after_throw (line 210) | pub fn panic_after_throw(mut cx: FunctionContext) -> JsResult<JsUndefine...
  function num_arguments (line 216) | pub fn num_arguments(mut cx: FunctionContext) -> JsResult<JsNumber> {
  function return_this (line 221) | pub fn return_this(mut cx: FunctionContext) -> JsResult<JsValue> {
  function require_object_this (line 225) | pub fn require_object_this(mut cx: FunctionContext) -> JsResult<JsUndefi...
  function is_argument_zero_some (line 232) | pub fn is_argument_zero_some(mut cx: FunctionContext) -> JsResult<JsBool...
  function require_argument_zero_string (line 237) | pub fn require_argument_zero_string(mut cx: FunctionContext) -> JsResult...
  function execute_scoped (line 242) | pub fn execute_scoped(mut cx: FunctionContext) -> JsResult<JsNumber> {
  function compute_scoped (line 253) | pub fn compute_scoped(mut cx: FunctionContext) -> JsResult<JsNumber> {
  function recompute_scoped (line 268) | pub fn recompute_scoped(mut cx: FunctionContext) -> JsResult<JsValue> {
  function throw_and_catch (line 274) | pub fn throw_and_catch(mut cx: FunctionContext) -> JsResult<JsValue> {
  function call_and_catch (line 284) | pub fn call_and_catch(mut cx: FunctionContext) -> JsResult<JsValue> {
  function get_number_or_default (line 291) | pub fn get_number_or_default(mut cx: FunctionContext) -> JsResult<JsNumb...
  function assume_this_is_an_object (line 299) | pub fn assume_this_is_an_object(mut cx: FunctionContext) -> JsResult<JsO...
  function is_construct (line 321) | pub fn is_construct(mut cx: FunctionContext) -> JsResult<JsObject> {
  function caller_with_drop_callback (line 337) | pub fn caller_with_drop_callback(mut cx: FunctionContext) -> JsResult<Js...

FILE: test/napi/src/js/futures.rs
  function lazy_async_add (line 16) | pub fn lazy_async_add(mut cx: FunctionContext) -> JsResult<JsPromise> {
  function lazy_async_sum (line 50) | pub fn lazy_async_sum(mut cx: FunctionContext) -> JsResult<JsPromise> {
  function async_fn_add (line 83) | async fn async_fn_add(a: f64, b: f64) -> f64 {
  function async_add (line 88) | fn async_add(a: f64, b: f64) -> impl Future<Output = f64> {
  function async_fn_div (line 93) | async fn async_fn_div(a: f64, b: f64) -> Result<f64, Error> {
  function async_div (line 102) | fn async_div(cx: &mut FunctionContext) -> NeonResult<impl Future<Output ...
  function async_with_events (line 115) | fn async_with_events(
  function await_callback (line 140) | async fn await_callback(ch: Channel, cb: Root<JsFunction>) -> Result<Roo...

FILE: test/napi/src/js/numbers.rs
  function return_js_number (line 3) | pub fn return_js_number(mut cx: FunctionContext) -> JsResult<JsNumber> {
  function return_large_js_number (line 7) | pub fn return_large_js_number(mut cx: FunctionContext) -> JsResult<JsNum...
  function return_negative_js_number (line 11) | pub fn return_negative_js_number(mut cx: FunctionContext) -> JsResult<Js...
  function return_float_js_number (line 15) | pub fn return_float_js_number(mut cx: FunctionContext) -> JsResult<JsNum...
  function return_negative_float_js_number (line 19) | pub fn return_negative_float_js_number(mut cx: FunctionContext) -> JsRes...
  function accept_and_return_js_number (line 23) | pub fn accept_and_return_js_number(mut cx: FunctionContext) -> JsResult<...
  function accept_and_return_large_js_number (line 28) | pub fn accept_and_return_large_js_number(mut cx: FunctionContext) -> JsR...
  function accept_and_return_float_js_number (line 33) | pub fn accept_and_return_float_js_number(mut cx: FunctionContext) -> JsR...
  function accept_and_return_negative_js_number (line 38) | pub fn accept_and_return_negative_js_number(mut cx: FunctionContext) -> ...

FILE: test/napi/src/js/objects.rs
  function return_js_global_object (line 5) | pub fn return_js_global_object(mut cx: FunctionContext) -> JsResult<JsOb...
  function return_js_object (line 9) | pub fn return_js_object(mut cx: FunctionContext) -> JsResult<JsObject> {
  function return_js_object_with_mixed_content (line 13) | pub fn return_js_object_with_mixed_content(mut cx: FunctionContext) -> J...
  function return_js_object_with_number (line 22) | pub fn return_js_object_with_number(mut cx: FunctionContext) -> JsResult...
  function return_js_object_with_string (line 29) | pub fn return_js_object_with_string(mut cx: FunctionContext) -> JsResult...
  function freeze_js_object (line 36) | pub fn freeze_js_object(mut cx: FunctionContext) -> JsResult<JsUndefined> {
  function seal_js_object (line 44) | pub fn seal_js_object(mut cx: FunctionContext) -> JsResult<JsUndefined> {
  function get_bytes (line 54) | fn get_bytes<'cx, 'a, C>(cx: &'a mut C, v: Handle<JsValue>) -> NeonResul...
  function byte_length (line 69) | pub fn byte_length(mut cx: FunctionContext) -> JsResult<JsNumber> {
  function call_nullary_method (line 80) | pub fn call_nullary_method(mut cx: FunctionContext) -> JsResult<JsNumber> {
  function call_unary_method (line 85) | pub fn call_unary_method(mut cx: FunctionContext) -> JsResult<JsNumber> {
  function call_symbol_method (line 93) | pub fn call_symbol_method(mut cx: FunctionContext) -> JsResult<JsString> {
  function get_property_with_prop (line 99) | pub fn get_property_with_prop(mut cx: FunctionContext) -> JsResult<JsNum...
  function set_property_with_prop (line 105) | pub fn set_property_with_prop(mut cx: FunctionContext) -> JsResult<JsUnd...
  function call_methods_with_prop (line 111) | pub fn call_methods_with_prop(mut cx: FunctionContext) -> JsResult<JsStr...
  function call_non_method_with_prop (line 120) | pub fn call_non_method_with_prop(mut cx: FunctionContext) -> JsResult<Js...

FILE: test/napi/src/js/strings.rs
  function return_js_string (line 3) | pub fn return_js_string(mut cx: FunctionContext) -> JsResult<JsString> {
  function return_js_string_utf16 (line 7) | pub fn return_js_string_utf16(mut cx: FunctionContext) -> JsResult<JsTyp...
  function return_length_utf8 (line 12) | pub fn return_length_utf8(mut cx: FunctionContext) -> JsResult<JsNumber> {
  function return_length_utf16 (line 17) | pub fn return_length_utf16(mut cx: FunctionContext) -> JsResult<JsNumber> {
  function run_string_as_script (line 22) | pub fn run_string_as_script(mut cx: FunctionContext) -> JsResult<JsValue> {

FILE: test/napi/src/js/threads.rs
  function useless_root (line 8) | pub fn useless_root(mut cx: FunctionContext) -> JsResult<JsObject> {
  function thread_callback (line 16) | pub fn thread_callback(mut cx: FunctionContext) -> JsResult<JsUndefined> {
  function multi_threaded_callback (line 27) | pub fn multi_threaded_callback(mut cx: FunctionContext) -> JsResult<JsUn...
  type BoxedGreeter (line 52) | type BoxedGreeter = JsBox<RefCell<AsyncGreeter>>;
  type AsyncGreeter (line 54) | pub struct AsyncGreeter {
    method greet (line 62) | fn greet<'a, C: Context<'a>>(&self, mut cx: C) -> JsResult<'a, JsUndef...
  method finalize (line 82) | fn finalize<'a, C: Context<'a>>(self, cx: &mut C) {
  function greeter_new (line 95) | pub fn greeter_new(mut cx: FunctionContext) -> JsResult<BoxedGreeter> {
  function greeter_greet (line 116) | pub fn greeter_greet(mut cx: FunctionContext) -> JsResult<JsUndefined> {
  function leak_channel (line 123) | pub fn leak_channel(mut cx: FunctionContext) -> JsResult<JsUndefined> {
  function drop_global_queue (line 135) | pub fn drop_global_queue(mut cx: FunctionContext) -> JsResult<JsUndefine...
  function channel_join (line 174) | pub fn channel_join(mut cx: FunctionContext) -> JsResult<JsUndefined> {
  function sum (line 217) | pub fn sum(mut cx: FunctionContext) -> JsResult<JsPromise> {
  function sum_manual_promise (line 227) | pub fn sum_manual_promise(mut cx: FunctionContext) -> JsResult<JsPromise> {
  function sum_rust_thread (line 242) | pub fn sum_rust_thread(mut cx: FunctionContext) -> JsResult<JsPromise> {
  function leak_promise (line 257) | pub fn leak_promise(mut cx: FunctionContext) -> JsResult<JsPromise> {
  function channel_panic (line 263) | pub fn channel_panic(mut cx: FunctionContext) -> JsResult<JsUndefined> {
  function channel_throw (line 276) | pub fn channel_throw(mut cx: FunctionContext) -> JsResult<JsUndefined> {
  function channel_panic_throw (line 290) | pub fn channel_panic_throw(mut cx: FunctionContext) -> JsResult<JsUndefi...
  type CustomPanic (line 308) | struct CustomPanic(String);
  function channel_custom_panic (line 310) | pub fn channel_custom_panic(mut cx: FunctionContext) -> JsResult<JsUndef...
  function custom_panic_downcast (line 323) | pub fn custom_panic_downcast(mut cx: FunctionContext) -> JsResult<JsStri...
  function task_panic_execute (line 329) | pub fn task_panic_execute(mut cx: FunctionContext) -> JsResult<JsUndefin...
  function task_panic_complete (line 337) | pub fn task_panic_complete(mut cx: FunctionContext) -> JsResult<JsUndefi...
  function task_throw (line 345) | pub fn task_throw(mut cx: FunctionContext) -> JsResult<JsUndefined> {
  function task_panic_throw (line 356) | pub fn task_panic_throw(mut cx: FunctionContext) -> JsResult<JsUndefined> {
  function task_custom_panic (line 371) | pub fn task_custom_panic(mut cx: FunctionContext) -> JsResult<JsUndefine...
  function task_reject_promise (line 380) | pub fn task_reject_promise(mut cx: FunctionContext) -> JsResult<JsPromis...
  function task_panic_execute_promise (line 389) | pub fn task_panic_execute_promise(mut cx: FunctionContext) -> JsResult<J...
  function task_panic_complete_promise (line 398) | pub fn task_panic_complete_promise(mut cx: FunctionContext) -> JsResult<...
  function task_panic_throw_promise (line 407) | pub fn task_panic_throw_promise(mut cx: FunctionContext) -> JsResult<JsP...
  function deferred_settle_with_throw (line 421) | pub fn deferred_settle_with_throw(mut cx: FunctionContext) -> JsResult<J...
  function deferred_settle_with_panic (line 437) | pub fn deferred_settle_with_panic(mut cx: FunctionContext) -> JsResult<J...
  function deferred_settle_with_panic_throw (line 451) | pub fn deferred_settle_with_panic_throw(mut cx: FunctionContext) -> JsRe...
  function block_task_callback (line 471) | fn block_task_callback(ch: Channel, cb: Root<JsFunction>) -> Result<Root...
  function settle_hello_world (line 487) | fn settle_hello_world<'cx>(cx: &mut Cx<'cx>) -> JsResult<'cx, JsPromise> {

FILE: test/napi/src/js/typedarrays.rs
  function return_array_buffer (line 6) | pub fn return_array_buffer(mut cx: FunctionContext) -> JsResult<JsArrayB...
  function return_array_buffer_from_slice (line 11) | pub fn return_array_buffer_from_slice(mut cx: FunctionContext) -> JsResu...
  function read_array_buffer_with_lock (line 18) | pub fn read_array_buffer_with_lock(mut cx: FunctionContext) -> JsResult<...
  function read_array_buffer_with_borrow (line 27) | pub fn read_array_buffer_with_borrow(mut cx: FunctionContext) -> JsResul...
  function write_array_buffer_with_lock (line 35) | pub fn write_array_buffer_with_lock(mut cx: FunctionContext) -> JsResult...
  function write_array_buffer_with_borrow_mut (line 50) | pub fn write_array_buffer_with_borrow_mut(mut cx: FunctionContext) -> Js...
  function read_typed_array_with_borrow (line 60) | pub fn read_typed_array_with_borrow(mut cx: FunctionContext) -> JsResult...
  function write_typed_array_with_borrow_mut (line 68) | pub fn write_typed_array_with_borrow_mut(mut cx: FunctionContext) -> JsR...
  function read_u8_typed_array (line 78) | pub fn read_u8_typed_array(mut cx: FunctionContext) -> JsResult<JsNumber> {
  function copy_typed_array (line 86) | pub fn copy_typed_array(mut cx: FunctionContext) -> JsResult<JsUndefined> {
  function return_uninitialized_buffer (line 104) | pub fn return_uninitialized_buffer(mut cx: FunctionContext) -> JsResult<...
  function return_buffer (line 109) | pub fn return_buffer(mut cx: FunctionContext) -> JsResult<JsBuffer> {
  function return_external_buffer (line 114) | pub fn return_external_buffer(mut cx: FunctionContext) -> JsResult<JsBuf...
  function return_external_array_buffer (line 121) | pub fn return_external_array_buffer(mut cx: FunctionContext) -> JsResult...
  function return_int8array_from_arraybuffer (line 128) | pub fn return_int8array_from_arraybuffer(mut cx: FunctionContext) -> JsR...
  function return_int16array_from_arraybuffer (line 133) | pub fn return_int16array_from_arraybuffer(mut cx: FunctionContext) -> Js...
  function return_uint32array_from_arraybuffer (line 138) | pub fn return_uint32array_from_arraybuffer(mut cx: FunctionContext) -> J...
  function return_float64array_from_arraybuffer (line 143) | pub fn return_float64array_from_arraybuffer(mut cx: FunctionContext) -> ...
  function return_biguint64array_from_arraybuffer (line 148) | pub fn return_biguint64array_from_arraybuffer(
  function return_new_int32array (line 155) | pub fn return_new_int32array(mut cx: FunctionContext) -> JsResult<JsInt3...
  function return_int32array_from_slice (line 160) | pub fn return_int32array_from_slice(mut cx: FunctionContext) -> JsResult...
  function return_uint32array_from_arraybuffer_region (line 172) | pub fn return_uint32array_from_arraybuffer_region(
  function get_arraybuffer_byte_length (line 183) | pub fn get_arraybuffer_byte_length(mut cx: FunctionContext) -> JsResult<...
  function typed_array_info (line 190) | fn typed_array_info<'cx, C, T: Binary>(
  function detach_and_then (line 219) | fn detach_and_then<'cx, F>(mut cx: FunctionContext<'cx>, f: F) -> JsResu...
  function detach_same_handle (line 247) | pub fn detach_same_handle(cx: FunctionContext) -> JsResult<JsObject> {
  function detach_and_escape (line 251) | pub fn detach_and_escape(cx: FunctionContext) -> JsResult<JsObject> {
  function detach_and_cast (line 258) | pub fn detach_and_cast(cx: FunctionContext) -> JsResult<JsObject> {
  function detach_and_unroot (line 266) | pub fn detach_and_unroot(cx: FunctionContext) -> JsResult<JsObject> {
  function get_typed_array_info (line 274) | pub fn get_typed_array_info(mut cx: FunctionContext) -> JsResult<JsObjec...
  function build_f32_region (line 302) | pub fn build_f32_region(mut cx: FunctionContext) -> JsResult<JsValue> {
  function build_f64_region (line 321) | pub fn build_f64_region(mut cx: FunctionContext) -> JsResult<JsValue> {
  function read_buffer_with_lock (line 340) | pub fn read_buffer_with_lock(mut cx: FunctionContext) -> JsResult<JsNumb...
  function read_buffer_with_borrow (line 352) | pub fn read_buffer_with_borrow(mut cx: FunctionContext) -> JsResult<JsNu...
  function write_buffer_with_lock (line 360) | pub fn write_buffer_with_lock(mut cx: FunctionContext) -> JsResult<JsUnd...
  function write_buffer_with_borrow_mut (line 373) | pub fn write_buffer_with_borrow_mut(mut cx: FunctionContext) -> JsResult...
  function copy_buffer (line 383) | pub fn copy_buffer(mut cx: FunctionContext) -> JsResult<JsUndefined> {
  function copy_buffer_with_borrow (line 396) | pub fn copy_buffer_with_borrow(mut cx: FunctionContext) -> JsResult<JsUn...

FILE: test/napi/src/js/types.rs
  function is_string (line 3) | pub fn is_string(mut cx: FunctionContext) -> JsResult<JsBoolean> {
  function is_array (line 9) | pub fn is_array(mut cx: FunctionContext) -> JsResult<JsBoolean> {
  function is_array_buffer (line 15) | pub fn is_array_buffer(mut cx: FunctionContext) -> JsResult<JsBoolean> {
  function is_uint32_array (line 21) | pub fn is_uint32_array(mut cx: FunctionContext) -> JsResult<JsBoolean> {
  function is_boolean (line 27) | pub fn is_boolean(mut cx: FunctionContext) -> JsResult<JsBoolean> {
  function is_buffer (line 33) | pub fn is_buffer(mut cx: FunctionContext) -> JsResult<JsBoolean> {
  function is_error (line 39) | pub fn is_error(mut cx: FunctionContext) -> JsResult<JsBoolean> {
  function is_null (line 45) | pub fn is_null(mut cx: FunctionContext) -> JsResult<JsBoolean> {
  function is_number (line 51) | pub fn is_number(mut cx: FunctionContext) -> JsResult<JsBoolean> {
  function is_object (line 57) | pub fn is_object(mut cx: FunctionContext) -> JsResult<JsBoolean> {
  function is_undefined (line 63) | pub fn is_undefined(mut cx: FunctionContext) -> JsResult<JsBoolean> {
  function strict_equals (line 69) | pub fn strict_equals(mut cx: FunctionContext) -> JsResult<JsBoolean> {

FILE: test/napi/src/js/workers.rs
  function get_and_replace (line 8) | pub fn get_and_replace(mut cx: FunctionContext) -> JsResult<JsValue> {
  function get_or_init (line 21) | pub fn get_or_init(mut cx: FunctionContext) -> JsResult<JsObject> {
  function get_or_init_clone (line 34) | pub fn get_or_init_clone(mut cx: FunctionContext) -> JsResult<JsObject> {
  function get_or_init_thread_id (line 51) | pub fn get_or_init_thread_id(mut cx: FunctionContext) -> JsResult<JsNumb...
  function reentrant_try_init (line 59) | pub fn reentrant_try_init(mut cx: FunctionContext) -> JsResult<JsNumber> {
  function get_reentrant_value (line 68) | pub fn get_reentrant_value(mut cx: FunctionContext) -> JsResult<JsValue> {
  function stash_global_object (line 78) | pub fn stash_global_object(mut cx: FunctionContext) -> JsResult<JsUndefi...
  function unstash_global_object (line 87) | pub fn unstash_global_object(mut cx: FunctionContext) -> JsResult<JsValu...
  function reject_after (line 94) | pub fn reject_after(mut cx: FunctionContext) -> JsResult<JsPromise> {
  type Channels (line 112) | pub struct Channels {
  function box_channels (line 118) | pub fn box_channels(mut cx: FunctionContext) -> JsResult<JsBox<Channels>> {

FILE: test/napi/src/lib.rs
  function main (line 33) | fn main(mut cx: ModuleContext) -> NeonResult<()> {
  function runtime (line 480) | fn runtime<'a, C: Context<'a>>(cx: &mut C) -> NeonResult<&'static Runtim...

FILE: test/rust-2024/src/lib.rs
  function hello (line 2) | fn hello() -> String {

FILE: test/ui/src/lib.rs
  function ui (line 3) | fn ui() {

FILE: test/ui/tests/fail/class-async-borrowed-channel.rs
  type Example (line 3) | struct Example;
    method method (line 8) | fn method(&self, _ch: &Channel) {}
  function main (line 11) | fn main() {}

FILE: test/ui/tests/fail/class-async-context-ref.rs
  type Example (line 3) | struct Example;
    method method (line 8) | fn method(&self, _cx: &mut FunctionContext) {}
  function main (line 11) | fn main() {}

FILE: test/ui/tests/fail/class-async-fn-borrowed-self.rs
  type Example (line 2) | struct Example;
    method method (line 6) | async fn method(&self) {}
  function main (line 9) | fn main() {}

FILE: test/ui/tests/fail/class-async-owned-context.rs
  type Example (line 3) | struct Example;
    method method (line 8) | fn method(&self, _cx: FunctionContext) {}
  function main (line 11) | fn main() {}

FILE: test/ui/tests/fail/class-borrowed-channel-sync.rs
  type Example (line 3) | struct Example;
    method method (line 7) | fn method(&self, _ch: &Channel) {}
  function main (line 10) | fn main() {}

FILE: test/ui/tests/fail/class-channel-in-sync.rs
  type Example (line 3) | struct Example;
    method method (line 7) | fn method(&self, _ch: Channel) {}
  function main (line 10) | fn main() {}

FILE: test/ui/tests/fail/class-constructor-self-receiver.rs
  type Example (line 1) | struct Example;
    method new (line 5) | fn new(&self) -> Self {
  function main (line 10) | fn main() {}

FILE: test/ui/tests/fail/class-constructor-with-self.rs
  type Example (line 1) | struct Example;
    method new (line 5) | fn new(self) -> Self {
  function main (line 10) | fn main() {}

FILE: test/ui/tests/fail/class-duplicate-property-names.rs
  type Example (line 1) | struct Example;
    constant VALUE1 (line 6) | const VALUE1: i32 = 42;
    constant VALUE2 (line 9) | const VALUE2: i32 = 43;
  function main (line 12) | fn main() {}

FILE: test/ui/tests/fail/class-immutable-context.rs
  type Example (line 3) | struct Example;
    method method (line 7) | fn method(&self, _cx: &FunctionContext) {}
  function main (line 10) | fn main() {}

FILE: test/ui/tests/fail/class-invalid-item-type.rs
  type Example (line 1) | struct Example;
    type AssocType (line 5) | type AssocType = i32;
  function main (line 8) | fn main() {}

FILE: test/ui/tests/fail/class-invalid-property-name.rs
  type Example (line 1) | struct Example;
    constant VALUE (line 6) | const VALUE: i32 = 42;
  function main (line 9) | fn main() {}

FILE: test/ui/tests/fail/class-method-missing-self.rs
  type Example (line 1) | struct Example;
    method method (line 5) | fn method() {}
  function main (line 8) | fn main() {}

FILE: test/ui/tests/fail/class-missing-forced-context.rs
  type Example (line 1) | struct Example;
    method method (line 6) | fn method(&self) {}
  function main (line 9) | fn main() {}

FILE: test/ui/tests/fail/class-multiple-constructors.rs
  type Example (line 1) | struct Example;
    method new (line 5) | fn new() -> Self {
    method new (line 9) | fn new() -> Self {
  function main (line 14) | fn main() {}

FILE: test/ui/tests/fail/class-multiple-finalizers.rs
  type Example (line 1) | struct Example;
    method finalize (line 5) | fn finalize<'a, C: neon::context::Context<'a>>(self, _cx: &mut C) {}
    method finalize (line 6) | fn finalize<'a, C: neon::context::Context<'a>>(self, _cx: &mut C) {}
  function main (line 9) | fn main() {}

FILE: test/ui/tests/fail/class-multiple-neon-attrs-const.rs
  type Example (line 1) | struct Example;
    constant VALUE (line 7) | const VALUE: i32 = 42;
  function main (line 10) | fn main() {}

FILE: test/ui/tests/fail/class-multiple-neon-attrs-method.rs
  type Example (line 1) | struct Example;
    method method (line 7) | fn method(&self) {}
  function main (line 10) | fn main() {}

FILE: test/ui/tests/fail/class-owned-context.rs
  type Example (line 3) | struct Example;
    method method (line 7) | fn method(&self, _cx: FunctionContext) {}
  function main (line 10) | fn main() {}

FILE: test/ui/tests/fail/missing-class-clone.rs
  type Point (line 1) | struct Point {
    method new (line 8) | fn new(x: i32, y: i32) -> Self {
    method equals (line 12) | fn equals(&self, other: Point) -> bool {
  function main (line 17) | fn main() {}

FILE: test/ui/tests/fail/missing-class-default.rs
  type Point (line 1) | struct Point {
  function main (line 10) | fn main() {}

FILE: test/ui/tests/fail/missing-context.rs
  function missing_context (line 2) | fn missing_context() {}
  function main (line 4) | fn main() {}

FILE: test/ui/tests/fail/need-borrowed-context.rs
  function owned_cx (line 2) | fn owned_cx(_cx: Cx) {}
  function owned_function_cx (line 5) | fn owned_function_cx(_cx: FunctionContext) {}
  function ref_cx (line 8) | fn ref_cx(_cx: &Cx) {}
  function ref_function_cx (line 11) | fn ref_function_cx(_cx: &FunctionContext) {}
  function forced_cx (line 14) | fn forced_cx(_cx: String) {}
  function forced_ref_cx (line 17) | fn forced_ref_cx(_cx: &String) {}
  function main (line 19) | fn main() {}

FILE: test/ui/tests/fail/unexpected-self.rs
  type Example (line 1) | struct Example;
    method borrow (line 5) | fn borrow(&self) {}
    method borrow_mut (line 8) | fn borrow_mut(&mut self) {}
    method owned (line 11) | fn owned(self) {}
  function main (line 14) | fn main() {}

FILE: test/ui/tests/fail/unnecessary-attribute.rs
  function async_with_async (line 2) | async fn async_with_async() {}
  function main (line 4) | fn main() {}

FILE: test/ui/tests/fail/unsupported-property.rs
  function unsupported (line 5) | fn unsupported() {}
  function main (line 7) | fn main() {}

FILE: test/ui/tests/fail/wrong-context.rs
  function sync_channel (line 2) | fn sync_channel(_ch: Channel) {}
  function sync_borrow_channel (line 5) | fn sync_borrow_channel(_ch: &mut Channel) {}
  function async_channel (line 8) | fn async_channel(_ch: Channel) {}
  function async_borrow_channel (line 11) | fn async_borrow_channel(_ch: &mut Channel) {}
  function async_cx (line 14) | async fn async_cx(_cx: Cx) {}
  function async_function_context (line 17) | async fn async_function_context(_cx: FunctionContext) {}
  function async_cx_ref (line 20) | async fn async_cx_ref(_cx: &Cx) {}
  function async_borrow_channel (line 23) | async fn async_borrow_channel(_cx: &Channel) {}
  function async_borrow_forced_channel (line 26) | async fn async_borrow_forced_channel(_cx: &String) {}
  function async_function_context_ref (line 29) | async fn async_function_context_ref(_cx: &FunctionContext) {}
  function task_function_context (line 32) | fn task_function_context(_cx: FunctionContext) {}
  function task_cx_ref (line 35) | fn task_cx_ref(_cx: &Cx) {}
  function task_function_context_ref (line 38) | fn task_function_context_ref(_cx: &FunctionContext) {}
  function main (line 40) | fn main() {}

FILE: test/ui/tests/pass/context-and-this.rs
  type Ch (line 10) | type Ch = Channel;
  type FnCx (line 11) | type FnCx<'cx> = FunctionContext<'cx>;
  function sync_nothing (line 14) | fn sync_nothing() {}
  function sync_function_context (line 17) | fn sync_function_context(_cx: &mut FunctionContext) {}
  function sync_cx (line 20) | fn sync_cx(_cx: &mut Cx) {}
  function sync_cx_forced (line 23) | fn sync_cx_forced(_cx: &mut FnCx) {}
  function sync_cx_lifetimes (line 26) | fn sync_cx_lifetimes<'cx>(cx: &mut Cx<'cx>) -> Handle<'cx, JsString> {
  function sync_this (line 31) | fn sync_this(this: Vec<u8>) {
  function sync_this_forced (line 36) | fn sync_this_forced(_this: Vec<u8>) {}
  function sync_cx_and_this (line 39) | fn sync_cx_and_this(_cx: &mut Cx, this: Vec<u8>) {
  function sync_cx_and_this_and_args (line 44) | fn sync_cx_and_this_and_args(_cx: &mut Cx, this: Vec<u8>, _a: String) {
  function boxed_this (line 49) | fn boxed_this(Boxed(this): Boxed<String>) {
  function async_nothing (line 54) | async fn async_nothing() {}
  function async_channel (line 57) | async fn async_channel(_ch: Channel) {}
  function async_channel_forced (line 60) | async fn async_channel_forced(_ch: Ch) {}
  function async_channel_and_arg (line 63) | async fn async_channel_and_arg(_ch: Channel, _a: String) {}
  function async_no_channel (line 66) | async fn async_no_channel(_a: String) {}
  function async_this (line 69) | async fn async_this(this: Vec<u8>) {
  function async_this_forced (line 74) | async fn async_this_forced(_this: Vec<u8>) {}
  function async_this_args (line 77) | async fn async_this_args(this: Vec<u8>, _a: String) {
  function async_this_and_channel (line 82) | async fn async_this_and_channel(_ch: Channel, this: Vec<u8>) {
  function async_this_and_channel_args (line 87) | async fn async_this_and_channel_args(_ch: Channel, this: Vec<u8>, _a: St...
  function task_nothing (line 92) | fn task_nothing() {}
  function task_channel (line 95) | fn task_channel(_ch: Channel) {}
  function task_channel_forced (line 98) | fn task_channel_forced(_ch: Ch) {}
  function task_channel_and_arg (line 101) | fn task_channel_and_arg(_ch: Channel, _a: String) {}
  function task_no_channel (line 104) | fn task_no_channel(_a: String) {}
  function task_this (line 107) | fn task_this(this: Vec<u8>) {
  function task_this_forced (line 112) | fn task_this_forced(_this: Vec<u8>) {}
  function task_this_args (line 115) | fn task_this_args(this: Vec<u8>, _a: String) {
  function task_this_and_channel (line 120) | fn task_this_and_channel(_ch: Channel, this: Vec<u8>) {
  function task_this_and_channel_args (line 125) | fn task_this_and_channel_args(_ch: Channel, this: Vec<u8>, _a: String, _...
  function impl_async_context (line 130) | fn impl_async_context(_cx: &mut Cx) -> impl Future<Output = ()> {
  function main (line 134) | fn main() {}

FILE: test/ui/tests/pass/globals.rs
  constant CONST_NUMBER (line 5) | const CONST_NUMBER: f64 = 42.0;
  function main (line 13) | fn main() {}

FILE: test/ui/tests/pass/json.rs
  function wrap_with_json (line 2) | fn wrap_with_json(v: Vec<String>) -> Vec<String> {
  function main (line 6) | fn main() {}