Full Code of neon-bindings/neon for AI

gitextract_5xdlnvd5/

├── .cargo/
│   └── config.toml
├── .editorconfig
├── .github/
│   └── workflows/
│       ├── bench.yml
│       ├── ci.yml
│       └── lint.yml
├── .gitignore
├── .prettierignore
├── AUTHORS.md
├── CODE_OF_CONDUCT.md
├── CONTRIBUTING.md
├── Cargo.toml
├── LICENSE-APACHE
├── LICENSE-MIT
├── README.md
├── RELEASES.md
├── bench/
│   ├── .gitignore
│   ├── Cargo.toml
│   ├── README.md
│   ├── index.js
│   ├── package.json
│   └── src/
│       └── lib.rs
├── codecov.yml
├── crates/
│   ├── neon/
│   │   ├── Cargo.toml
│   │   └── src/
│   │       ├── context/
│   │       │   ├── internal.rs
│   │       │   └── mod.rs
│   │       ├── event/
│   │       │   ├── channel.rs
│   │       │   ├── mod.rs
│   │       │   └── task.rs
│   │       ├── executor/
│   │       │   ├── mod.rs
│   │       │   └── tokio.rs
│   │       ├── handle/
│   │       │   ├── internal.rs
│   │       │   ├── mod.rs
│   │       │   └── root.rs
│   │       ├── lib.rs
│   │       ├── lifecycle.rs
│   │       ├── macro_internal/
│   │       │   ├── futures.rs
│   │       │   └── mod.rs
│   │       ├── macros.rs
│   │       ├── meta.rs
│   │       ├── object/
│   │       │   ├── class.rs
│   │       │   ├── mod.rs
│   │       │   └── wrap.rs
│   │       ├── prelude.rs
│   │       ├── reflect.rs
│   │       ├── result/
│   │       │   └── mod.rs
│   │       ├── sys/
│   │       │   ├── array.rs
│   │       │   ├── arraybuffer.rs
│   │       │   ├── async_work.rs
│   │       │   ├── bindings/
│   │       │   │   ├── functions.rs
│   │       │   │   ├── mod.rs
│   │       │   │   └── types.rs
│   │       │   ├── buffer.rs
│   │       │   ├── call.rs
│   │       │   ├── convert.rs
│   │       │   ├── date.rs
│   │       │   ├── debug_send_wrapper.rs
│   │       │   ├── error.rs
│   │       │   ├── external.rs
│   │       │   ├── fun.rs
│   │       │   ├── lifecycle.rs
│   │       │   ├── mem.rs
│   │       │   ├── mod.rs
│   │       │   ├── no_panic.rs
│   │       │   ├── object.rs
│   │       │   ├── primitive.rs
│   │       │   ├── promise.rs
│   │       │   ├── raw.rs
│   │       │   ├── reference.rs
│   │       │   ├── scope.rs
│   │       │   ├── string.rs
│   │       │   ├── tag.rs
│   │       │   ├── tsfn.rs
│   │       │   └── typedarray.rs
│   │       ├── thread/
│   │       │   └── mod.rs
│   │       ├── types_docs.rs
│   │       └── types_impl/
│   │           ├── bigint.rs
│   │           ├── boxed.rs
│   │           ├── buffer/
│   │           │   ├── lock.rs
│   │           │   ├── mod.rs
│   │           │   └── types.rs
│   │           ├── date.rs
│   │           ├── error.rs
│   │           ├── extract/
│   │           │   ├── array.rs
│   │           │   ├── boxed.rs
│   │           │   ├── buffer.rs
│   │           │   ├── container.rs
│   │           │   ├── either.rs
│   │           │   ├── error.rs
│   │           │   ├── json.rs
│   │           │   ├── mod.rs
│   │           │   ├── private.rs
│   │           │   ├── try_from_js.rs
│   │           │   ├── try_into_js.rs
│   │           │   └── with.rs
│   │           ├── function/
│   │           │   ├── mod.rs
│   │           │   └── private.rs
│   │           ├── mod.rs
│   │           ├── private.rs
│   │           ├── promise.rs
│   │           └── utf8.rs
│   └── neon-macros/
│       ├── Cargo.toml
│       ├── LICENSE-APACHE
│       ├── LICENSE-MIT
│       └── src/
│           ├── class/
│           │   ├── meta.rs
│           │   └── mod.rs
│           ├── export/
│           │   ├── class/
│           │   │   └── meta.rs
│           │   ├── class.rs
│           │   ├── function/
│           │   │   ├── meta.rs
│           │   │   └── mod.rs
│           │   ├── global/
│           │   │   ├── meta.rs
│           │   │   └── mod.rs
│           │   └── mod.rs
│           ├── lib.rs
│           └── name.rs
├── doc/
│   ├── MIGRATION_GUIDE_0.10.md
│   ├── MIGRATION_GUIDE_1.0.0.md
│   └── MIGRATION_GUIDE_NAPI.md
├── package.json
├── pkgs/
│   ├── cargo-cp-artifact/
│   │   ├── LICENSE
│   │   ├── README.md
│   │   ├── bin/
│   │   │   └── cargo-cp-artifact.js
│   │   ├── package.json
│   │   ├── src/
│   │   │   ├── args.js
│   │   │   └── index.js
│   │   └── test/
│   │       └── args.js
│   └── create-neon/
│       ├── .mocharc.json
│       ├── README.md
│       ├── data/
│       │   ├── templates/
│       │   │   ├── .gitignore.hbs
│       │   │   ├── Cargo.toml.hbs
│       │   │   ├── README.md.hbs
│       │   │   ├── Workspace.toml.hbs
│       │   │   ├── ci/
│       │   │   │   └── github/
│       │   │   │       ├── build.yml.hbs
│       │   │   │       ├── release.yml.hbs
│       │   │   │       ├── setup.yml.hbs
│       │   │   │       └── test.yml.hbs
│       │   │   ├── lib.rs.hbs
│       │   │   ├── manifest/
│       │   │   │   └── base/
│       │   │   │       ├── default.json.hbs
│       │   │   │       └── library.json.hbs
│       │   │   ├── ts/
│       │   │   │   ├── index.cts.hbs
│       │   │   │   ├── index.mts.hbs
│       │   │   │   └── load.cts.hbs
│       │   │   └── tsconfig.json.hbs
│       │   └── versions.json
│       ├── dev/
│       │   └── expect.ts
│       ├── package.json
│       ├── src/
│       │   ├── bin/
│       │   │   └── create-neon.ts
│       │   ├── cache/
│       │   │   └── npm.ts
│       │   ├── cache.ts
│       │   ├── ci/
│       │   │   └── github.ts
│       │   ├── ci.ts
│       │   ├── create/
│       │   │   ├── app.ts
│       │   │   ├── creator.ts
│       │   │   └── lib.ts
│       │   ├── die.ts
│       │   ├── expand/
│       │   │   ├── context.ts
│       │   │   ├── index.ts
│       │   │   └── versions.ts
│       │   ├── fs.ts
│       │   ├── index.ts
│       │   ├── print.ts
│       │   └── shell.ts
│       ├── test/
│       │   └── create-neon.ts
│       └── tsconfig.json
└── test/
    ├── electron/
    │   ├── Cargo.toml
    │   ├── README.md
    │   ├── index.html
    │   ├── main.js
    │   ├── main.test.js
    │   ├── package.json
    │   ├── preload.js
    │   ├── renderer.js
    │   └── src/
    │       └── lib.rs
    ├── napi/
    │   ├── .gitignore
    │   ├── Cargo.toml
    │   ├── README.md
    │   ├── lib/
    │   │   ├── arrays.js
    │   │   ├── bigint.js
    │   │   ├── boxed.js
    │   │   ├── class.js
    │   │   ├── coercions.js
    │   │   ├── container.js
    │   │   ├── date.js
    │   │   ├── errors.js
    │   │   ├── export.js
    │   │   ├── extract.js
    │   │   ├── functions.js
    │   │   ├── futures.js
    │   │   ├── hello.js
    │   │   ├── numbers.js
    │   │   ├── objects.js
    │   │   ├── strings.js
    │   │   ├── threads.js
    │   │   ├── typedarrays.js
    │   │   ├── types.js
    │   │   └── workers.js
    │   ├── package.json
    │   └── src/
    │       ├── js/
    │       │   ├── arrays.rs
    │       │   ├── bigint.rs
    │       │   ├── boxed.rs
    │       │   ├── class.rs
    │       │   ├── coercions.rs
    │       │   ├── container.rs
    │       │   ├── date.rs
    │       │   ├── errors.rs
    │       │   ├── export.rs
    │       │   ├── extract.rs
    │       │   ├── functions.rs
    │       │   ├── futures.rs
    │       │   ├── numbers.rs
    │       │   ├── objects.rs
    │       │   ├── strings.rs
    │       │   ├── threads.rs
    │       │   ├── typedarrays.rs
    │       │   ├── types.rs
    │       │   └── workers.rs
    │       └── lib.rs
    ├── rust-2024/
    │   ├── .gitignore
    │   ├── Cargo.toml
    │   ├── README.md
    │   ├── package.json
    │   └── src/
    │       └── lib.rs
    └── ui/
        ├── Cargo.toml
        ├── src/
        │   └── lib.rs
        └── tests/
            ├── fail/
            │   ├── class-async-borrowed-channel.rs
            │   ├── class-async-borrowed-channel.stderr
            │   ├── class-async-context-ref.rs
            │   ├── class-async-context-ref.stderr
            │   ├── class-async-fn-borrowed-self.rs
            │   ├── class-async-fn-borrowed-self.stderr
            │   ├── class-async-owned-context.rs
            │   ├── class-async-owned-context.stderr
            │   ├── class-borrowed-channel-sync.rs
            │   ├── class-borrowed-channel-sync.stderr
            │   ├── class-channel-in-sync.rs
            │   ├── class-channel-in-sync.stderr
            │   ├── class-constructor-self-receiver.rs
            │   ├── class-constructor-self-receiver.stderr
            │   ├── class-constructor-with-self.rs
            │   ├── class-constructor-with-self.stderr
            │   ├── class-duplicate-property-names.rs
            │   ├── class-duplicate-property-names.stderr
            │   ├── class-immutable-context.rs
            │   ├── class-immutable-context.stderr
            │   ├── class-invalid-item-type.rs
            │   ├── class-invalid-item-type.stderr
            │   ├── class-invalid-property-name.rs
            │   ├── class-invalid-property-name.stderr
            │   ├── class-method-missing-self.rs
            │   ├── class-method-missing-self.stderr
            │   ├── class-missing-forced-context.rs
            │   ├── class-missing-forced-context.stderr
            │   ├── class-multiple-constructors.rs
            │   ├── class-multiple-constructors.stderr
            │   ├── class-multiple-finalizers.rs
            │   ├── class-multiple-finalizers.stderr
            │   ├── class-multiple-neon-attrs-const.rs
            │   ├── class-multiple-neon-attrs-const.stderr
            │   ├── class-multiple-neon-attrs-method.rs
            │   ├── class-multiple-neon-attrs-method.stderr
            │   ├── class-owned-context.rs
            │   ├── class-owned-context.stderr
            │   ├── missing-class-clone.rs
            │   ├── missing-class-clone.stderr
            │   ├── missing-class-default.rs
            │   ├── missing-class-default.stderr
            │   ├── missing-context.rs
            │   ├── missing-context.stderr
            │   ├── need-borrowed-context.rs
            │   ├── need-borrowed-context.stderr
            │   ├── unexpected-self.rs
            │   ├── unexpected-self.stderr
            │   ├── unnecessary-attribute.rs
            │   ├── unnecessary-attribute.stderr
            │   ├── unsupported-property.rs
            │   ├── unsupported-property.stderr
            │   ├── wrong-context.rs
            │   └── wrong-context.stderr
            └── pass/
                ├── context-and-this.rs
                ├── globals.rs
                └── json.rs

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() {}

[
  {
    "path": ".cargo/config.toml",
    "chars": 672,
    "preview": "[alias]\n# Neon defines mutually exclusive feature flags which prevents using `cargo clippy --all-features`\n# The followi"
  },
  {
    "path": ".editorconfig",
    "chars": 238,
    "preview": "root = true\n\n[*]\nindent_style = space\nindent_size = 2\nend_of_line = lf\ncharset = utf-8\ntrim_trailing_whitespace = true\ni"
  },
  {
    "path": ".github/workflows/bench.yml",
    "chars": 1812,
    "preview": "name: Benchmarks\n\non:\n  push:\n    branches:\n      - main\n  pull_request:\n    branches:\n      - main\n\njobs:\n  bench:\n    "
  },
  {
    "path": ".github/workflows/ci.yml",
    "chars": 4189,
    "preview": "name: CI\n\non:\n  push:\n    # Prevent duplicate runs of this workflow on our own internal PRs.\n    branches:\n      - main\n"
  },
  {
    "path": ".github/workflows/lint.yml",
    "chars": 1355,
    "preview": "name: Lints\n\non:\n  push:\n    # Prevent duplicate runs of this workflow on our own internal PRs.\n    branches:\n      - ma"
  },
  {
    "path": ".gitignore",
    "chars": 315,
    "preview": "# Rust\ntarget\nrls*.log\n\n# Created by `trybuild` ui tests\nwip\n**/*~\n\n# Node\n**/node_modules\nnpm-debug.log\n\n# JS build\n**/"
  },
  {
    "path": ".prettierignore",
    "chars": 75,
    "preview": ".git/\ncli/lib/\ntest/cli/lib/\nnode_modules/\n**/dist/\ntarget/\nartifacts.json\n"
  },
  {
    "path": "AUTHORS.md",
    "chars": 3581,
    "preview": "# Authors\n\nNeon owes its existence to the contributions of these fine people.\n\n* [Reza Akhavan](https://github.com/jedir"
  },
  {
    "path": "CODE_OF_CONDUCT.md",
    "chars": 3197,
    "preview": "# Contributor Covenant Code of Conduct\n\n## Our Pledge\n\nIn the interest of fostering an open and welcoming environment, w"
  },
  {
    "path": "CONTRIBUTING.md",
    "chars": 2281,
    "preview": "# Contributing to Neon\n\nNeon welcomes contribution from everyone. Here are some resources to help you join us!\n\n## Contr"
  },
  {
    "path": "Cargo.toml",
    "chars": 114,
    "preview": "[workspace]\nresolver = \"2\"\nmembers = [\n    \"crates/*\",\n    \"test/*\",\n    \"bench\",\n]\n\n[profile.release]\nlto = true\n"
  },
  {
    "path": "LICENSE-APACHE",
    "chars": 10847,
    "preview": "                              Apache License\n                        Version 2.0, January 2004\n                     http"
  },
  {
    "path": "LICENSE-MIT",
    "chars": 1056,
    "preview": "Copyright (c) 2015 David Herman\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this so"
  },
  {
    "path": "README.md",
    "chars": 4107,
    "preview": "# <img src=\"https://raw.githubusercontent.com/neon-bindings/neon/refs/heads/main/doc/neon.png\" alt=\"neon\" width=\"100%\" /"
  },
  {
    "path": "RELEASES.md",
    "chars": 31316,
    "preview": "# `cargo-cp-artifact`\n\n`0.1.9` supports a [breaking change in `cargo`](https://github.com/rust-lang/cargo/issues/13867) "
  },
  {
    "path": "bench/.gitignore",
    "chars": 46,
    "preview": "index.node\nnpm-debug.log*\ncargo.log\ncross.log\n"
  },
  {
    "path": "bench/Cargo.toml",
    "chars": 383,
    "preview": "[package]\nname = \"bench\"\nversion = \"0.1.0\"\ndescription = \"Neon performance regression suite\"\nauthors = [\"David Herman <d"
  },
  {
    "path": "bench/README.md",
    "chars": 200,
    "preview": "# bench: Neon performance regression suite\n\n## Building bench\n\nTo run the build, run:\n\n```sh\n$ npm run build\n```\n\n## Run"
  },
  {
    "path": "bench/index.js",
    "chars": 1754,
    "preview": "const { Suite, jsonReport } = require(\"bench-node\");\nconst addon = require(\"./index.node\");\n\nfunction median(values) {\n "
  },
  {
    "path": "bench/package.json",
    "chars": 777,
    "preview": "{\n  \"name\": \"bench\",\n  \"private\": true,\n  \"description\": \"Neon performance regression suite\",\n  \"main\": \"index.js\",\n  \"s"
  },
  {
    "path": "bench/src/lib.rs",
    "chars": 1633,
    "preview": "use neon::prelude::*;\n\n#[neon::export]\nfn export_noop() {}\n\nfn manual_noop(mut cx: FunctionContext) -> JsResult<JsUndefi"
  },
  {
    "path": "codecov.yml",
    "chars": 83,
    "preview": "ignore:\n  - \"bench\"\n  - \"test\"\ncoverage:\n  status:\n    project: off\n    patch: off\n"
  },
  {
    "path": "crates/neon/Cargo.toml",
    "chars": 3098,
    "preview": "[package]\nname = \"neon\"\nversion = \"1.1.1\"\nauthors = [\"Dave Herman <david.herman@gmail.com>\"]\ndescription = \"A safe abstr"
  },
  {
    "path": "crates/neon/src/context/internal.rs",
    "chars": 2222,
    "preview": "use std::{cell::RefCell, ffi::c_void, mem::MaybeUninit};\n\nuse crate::{\n    context::{Cx, ModuleContext},\n    handle::Han"
  },
  {
    "path": "crates/neon/src/context/mod.rs",
    "chars": 30685,
    "preview": "//! Provides runtime access to the JavaScript engine.\n//!\n//! An _execution context_ represents the current state of a t"
  },
  {
    "path": "crates/neon/src/event/channel.rs",
    "chars": 12639,
    "preview": "use std::{\n    error, fmt,\n    sync::{\n        atomic::{AtomicUsize, Ordering},\n        Arc,\n    },\n};\n\nuse crate::{\n   "
  },
  {
    "path": "crates/neon/src/event/mod.rs",
    "chars": 5407,
    "preview": "//! Exposes the JavaScript event loop for scheduling asynchronous events.\n//!\n//! ## The Event Loop\n//!\n//! The [_event "
  },
  {
    "path": "crates/neon/src/event/task.rs",
    "chars": 4134,
    "preview": "use std::{panic::resume_unwind, thread};\n\nuse crate::{\n    context::{internal::Env, Context, Cx},\n    handle::Handle,\n  "
  },
  {
    "path": "crates/neon/src/executor/mod.rs",
    "chars": 1710,
    "preview": "use std::{future::Future, pin::Pin};\n\nuse crate::{context::Cx, thread::LocalKey};\n\n#[cfg(feature = \"tokio-rt\")]\npub(crat"
  },
  {
    "path": "crates/neon/src/executor/tokio.rs",
    "chars": 1666,
    "preview": "use std::sync::Arc;\n\nuse super::{BoxFuture, Runtime};\n\nimpl Runtime for tokio::runtime::Runtime {\n    fn spawn(&self, fu"
  },
  {
    "path": "crates/neon/src/handle/internal.rs",
    "chars": 835,
    "preview": "use std::{fmt::Debug, mem};\n\nuse crate::types::Value;\n\npub trait SuperType<T: Value> {\n    fn upcast_internal(v: &T) -> "
  },
  {
    "path": "crates/neon/src/handle/mod.rs",
    "chars": 6578,
    "preview": "//! References to garbage-collected JavaScript values.\n//!\n//! A _handle_ is a safe reference to a JavaScript value that"
  },
  {
    "path": "crates/neon/src/handle/root.rs",
    "chars": 8038,
    "preview": "use std::{ffi::c_void, marker::PhantomData};\n\nuse crate::{\n    context::Context,\n    handle::Handle,\n    object::Object,"
  },
  {
    "path": "crates/neon/src/lib.rs",
    "chars": 7805,
    "preview": "//! The [Neon][neon] crate provides bindings for writing [Node.js addons][addons]\n//! (i.e., dynamically-loaded binary m"
  },
  {
    "path": "crates/neon/src/lifecycle.rs",
    "chars": 9204,
    "preview": "//! # Environment life cycle APIs\n//!\n//! These APIs map to the life cycle of a specific \"Agent\" or self-contained\n//! e"
  },
  {
    "path": "crates/neon/src/macro_internal/futures.rs",
    "chars": 759,
    "preview": "use std::future::Future;\n\nuse crate::{\n    context::{Context, Cx, TaskContext},\n    result::JsResult,\n    types::JsValue"
  },
  {
    "path": "crates/neon/src/macro_internal/mod.rs",
    "chars": 3676,
    "preview": "//! Internals needed by macros. These have to be exported for the macros to work\n\nuse std::marker::PhantomData;\n\npub use"
  },
  {
    "path": "crates/neon/src/macros.rs",
    "chars": 28862,
    "preview": "//! Helper module to add documentation to macros prior to re-exporting.\n\n#[cfg(feature = \"napi-6\")]\n/// Create a Neon cl"
  },
  {
    "path": "crates/neon/src/meta.rs",
    "chars": 720,
    "preview": "//! Metadata about the Neon version and build.\n\nuse semver::Version;\n\n/// The Neon version.\npub const VERSION: &str = en"
  },
  {
    "path": "crates/neon/src/object/class.rs",
    "chars": 2249,
    "preview": "use crate::{\n    context::Cx,\n    handle::{Handle, Root},\n    object::Object,\n    result::{JsResult, NeonResult},\n    ty"
  },
  {
    "path": "crates/neon/src/object/mod.rs",
    "chars": 12018,
    "preview": "//! Traits for working with JavaScript objects.\n//!\n//! This module defines the [`Object`] trait, which is implemented\n/"
  },
  {
    "path": "crates/neon/src/object/wrap.rs",
    "chars": 6878,
    "preview": "use std::{any::Any, error, ffi::c_void, fmt, mem::MaybeUninit, ptr};\n\nuse crate::{\n    context::{\n        internal::{Con"
  },
  {
    "path": "crates/neon/src/prelude.rs",
    "chars": 971,
    "preview": "//! Convenience module for the most common Neon imports.\n\n#[doc(no_inline)]\npub use crate::{\n    context::{CallKind, Con"
  },
  {
    "path": "crates/neon/src/reflect.rs",
    "chars": 455,
    "preview": "//! Exposes JavaScript's reflection API to Rust.\n\nuse crate::{\n    context::Context,\n    handle::Handle,\n    result::JsR"
  },
  {
    "path": "crates/neon/src/result/mod.rs",
    "chars": 3742,
    "preview": "//! Represents JavaScript exceptions as a Rust [`Result`](std::result) type.\n//!\n//! Most interactions with the JavaScri"
  },
  {
    "path": "crates/neon/src/sys/array.rs",
    "chars": 604,
    "preview": "//! Facilities for working with Array `napi_value`s.\n\nuse super::{\n    bindings as napi,\n    raw::{Env, Local},\n};\n\npub "
  },
  {
    "path": "crates/neon/src/sys/arraybuffer.rs",
    "chars": 2099,
    "preview": "#[cfg(feature = \"external-buffers\")]\nuse std::os::raw::c_void;\nuse std::{mem::MaybeUninit, ptr::null_mut, slice};\n\nuse s"
  },
  {
    "path": "crates/neon/src/sys/async_work.rs",
    "chars": 5649,
    "preview": "//! Rust wrappers for Node-API simple asynchronous operations\n//!\n//! Unlike `napi_async_work` which threads a single mu"
  },
  {
    "path": "crates/neon/src/sys/bindings/functions.rs",
    "chars": 16165,
    "preview": "#![allow(clippy::too_many_arguments)]\n\nmod napi1 {\n    use super::super::types::*;\n    use std::os::raw::{c_char, c_void"
  },
  {
    "path": "crates/neon/src/sys/bindings/mod.rs",
    "chars": 6077,
    "preview": "//! # FFI bindings to Node-API symbols\n//!\n//! Rust types generated from [Node-API](https://nodejs.org/api/n-api.html).\n"
  },
  {
    "path": "crates/neon/src/sys/bindings/types.rs",
    "chars": 8355,
    "preview": "use std::ffi::c_void;\n\n#[repr(C)]\n#[derive(Debug, Copy, Clone)]\n#[doc(hidden)]\npub struct Env__ {\n    _unused: [u8; 0],\n"
  },
  {
    "path": "crates/neon/src/sys/buffer.rs",
    "chars": 2347,
    "preview": "#[cfg(feature = \"external-buffers\")]\nuse std::os::raw::c_void;\nuse std::{mem::MaybeUninit, slice};\n\nuse super::{\n    bin"
  },
  {
    "path": "crates/neon/src/sys/call.rs",
    "chars": 3384,
    "preview": "use std::{mem::MaybeUninit, ptr::null_mut};\n\nuse smallvec::SmallVec;\n\nuse super::{\n    bindings as napi,\n    raw::{Env, "
  },
  {
    "path": "crates/neon/src/sys/convert.rs",
    "chars": 227,
    "preview": "use super::{\n    bindings as napi,\n    raw::{Env, Local},\n};\n\npub unsafe fn to_string(out: &mut Local, env: Env, value: "
  },
  {
    "path": "crates/neon/src/sys/date.rs",
    "chars": 813,
    "preview": "use std::mem::MaybeUninit;\n\nuse super::{\n    bindings as napi,\n    raw::{Env, Local},\n};\n\n/// Create a new date object\n/"
  },
  {
    "path": "crates/neon/src/sys/debug_send_wrapper.rs",
    "chars": 1158,
    "preview": "//! Wrapper that ensures types are always used from the same thread\n//! in debug builds. It is a zero-cost in release bu"
  },
  {
    "path": "crates/neon/src/sys/error.rs",
    "chars": 2334,
    "preview": "use std::{mem::MaybeUninit, panic::Location, ptr};\n\nuse super::{\n    bindings as napi,\n    raw::{Env, Local},\n};\n\npub un"
  },
  {
    "path": "crates/neon/src/sys/external.rs",
    "chars": 2967,
    "preview": "use std::mem::MaybeUninit;\n\nuse super::{\n    bindings as napi,\n    debug_send_wrapper::DebugSendWrapper,\n    raw::{Env, "
  },
  {
    "path": "crates/neon/src/sys/fun.rs",
    "chars": 2316,
    "preview": "//! Facilities for working with JS functions.\n\nuse std::{mem::MaybeUninit, os::raw::c_void, ptr};\n\nuse super::{\n    bind"
  },
  {
    "path": "crates/neon/src/sys/lifecycle.rs",
    "chars": 1412,
    "preview": "//! # Environment life cycle APIs\n//!\n//! These APIs map to the life cycle of a specific \"Agent\" or self-contained\n//! e"
  },
  {
    "path": "crates/neon/src/sys/mem.rs",
    "chars": 247,
    "preview": "use super::{\n    bindings as napi,\n    raw::{Env, Local},\n};\n\npub unsafe fn strict_equals(env: Env, lhs: Local, rhs: Loc"
  },
  {
    "path": "crates/neon/src/sys/mod.rs",
    "chars": 3972,
    "preview": "//! Raw bindings to [Node-API][node-api]\n//!\n//! [Node-API][node-api] is Node.js's API for building native addons. Neon "
  },
  {
    "path": "crates/neon/src/sys/no_panic.rs",
    "chars": 9274,
    "preview": "//! Utilities that _will_ not panic for use in contexts where unwinding would be\n//! undefined behavior.\n//!\n//! The fol"
  },
  {
    "path": "crates/neon/src/sys/object.rs",
    "chars": 5095,
    "preview": "use std::mem::MaybeUninit;\n\nuse super::{\n    bindings as napi,\n    raw::{Env, Local},\n};\n\n/// Mutates the `out` argument"
  },
  {
    "path": "crates/neon/src/sys/primitive.rs",
    "chars": 1514,
    "preview": "use super::{\n    bindings as napi,\n    raw::{Env, Local},\n};\n\n/// Mutates the `out` argument provided to refer to the gl"
  },
  {
    "path": "crates/neon/src/sys/promise.rs",
    "chars": 1822,
    "preview": "//! JavaScript Promise and Deferred handle\n//!\n//! See: [Promises in Node-API](https://nodejs.org/api/n-api.html#n_api_p"
  },
  {
    "path": "crates/neon/src/sys/raw.rs",
    "chars": 140,
    "preview": "use super::bindings as napi;\n\npub type Local = napi::Value;\n\npub type FunctionCallbackInfo = napi::CallbackInfo;\n\npub ty"
  },
  {
    "path": "crates/neon/src/sys/reference.rs",
    "chars": 1251,
    "preview": "use std::mem::MaybeUninit;\n\nuse super::{\n    bindings as napi,\n    raw::{Env, Local},\n};\n\npub unsafe fn new(env: Env, va"
  },
  {
    "path": "crates/neon/src/sys/scope.rs",
    "chars": 1639,
    "preview": "use std::mem::MaybeUninit;\n\nuse super::{\n    bindings as napi,\n    raw::{Env, Local},\n};\n\npub(crate) struct HandleScope "
  },
  {
    "path": "crates/neon/src/sys/string.rs",
    "chars": 1369,
    "preview": "use std::{mem::MaybeUninit, ptr};\n\nuse super::{\n    bindings as napi,\n    raw::{Env, Local},\n};\n\npub unsafe fn new(out: "
  },
  {
    "path": "crates/neon/src/sys/tag.rs",
    "chars": 3142,
    "preview": "use super::{\n    bindings as napi,\n    raw::{Env, Local},\n};\n\n/// Return true if an `napi_value` `val` has the expected "
  },
  {
    "path": "crates/neon/src/sys/tsfn.rs",
    "chars": 6158,
    "preview": "//! Idiomatic Rust wrappers for N-API threadsafe functions\n\nuse std::{\n    ffi::c_void,\n    mem::MaybeUninit,\n    ptr,\n "
  },
  {
    "path": "crates/neon/src/sys/typedarray.rs",
    "chars": 1559,
    "preview": "use std::{ffi::c_void, mem::MaybeUninit};\n\nuse super::{\n    bindings::{self as napi, TypedArrayType},\n    raw::{Env, Loc"
  },
  {
    "path": "crates/neon/src/thread/mod.rs",
    "chars": 9094,
    "preview": "//! Thread-local storage for JavaScript threads.\n//!\n//! At runtime, an instance of a Node.js addon can contain its own "
  },
  {
    "path": "crates/neon/src/types_docs.rs",
    "chars": 5813,
    "preview": "#[cfg_attr(feature = \"aquamarine\", aquamarine::aquamarine)]\n/// Representations of JavaScript's core builtin types.\n///\n"
  },
  {
    "path": "crates/neon/src/types_impl/bigint.rs",
    "chars": 12048,
    "preview": "//! Types for working with [`JsBigInt`].\n\nuse std::{error, fmt, mem::MaybeUninit};\n\nuse crate::{\n    context::{\n        "
  },
  {
    "path": "crates/neon/src/types_impl/boxed.rs",
    "chars": 14461,
    "preview": "use std::{\n    any::{self, Any},\n    ops::Deref,\n};\n\nuse crate::{\n    context::{\n        internal::{ContextInternal, Env"
  },
  {
    "path": "crates/neon/src/types_impl/buffer/lock.rs",
    "chars": 5677,
    "preview": "use std::{cell::RefCell, ops::Range};\n\nuse crate::{\n    context::Context,\n    types::buffer::{BorrowError, Ref, RefMut},"
  },
  {
    "path": "crates/neon/src/types_impl/buffer/mod.rs",
    "chars": 9006,
    "preview": "//! Types and traits for working with binary buffers.\n\nuse std::{\n    cell::RefCell,\n    error::Error,\n    fmt::{self, D"
  },
  {
    "path": "crates/neon/src/types_impl/buffer/types.rs",
    "chars": 30181,
    "preview": "use std::{marker::PhantomData, slice};\n\nuse crate::{\n    context::{\n        internal::{ContextInternal, Env},\n        Co"
  },
  {
    "path": "crates/neon/src/types_impl/date.rs",
    "chars": 5603,
    "preview": "use std::{\n    error::Error,\n    fmt::{self, Debug},\n};\n\nuse super::{private::ValueInternal, Value};\n\nuse crate::{\n    c"
  },
  {
    "path": "crates/neon/src/types_impl/error.rs",
    "chars": 4138,
    "preview": "//! Types and traits representing JavaScript error values.\n\nuse std::panic::{catch_unwind, UnwindSafe};\n\nuse crate::{\n  "
  },
  {
    "path": "crates/neon/src/types_impl/extract/array.rs",
    "chars": 5390,
    "preview": "use std::{error, fmt, mem::MaybeUninit};\n\nuse crate::{\n    context::{internal::ContextInternal, Context, Cx},\n    handle"
  },
  {
    "path": "crates/neon/src/types_impl/extract/boxed.rs",
    "chars": 1783,
    "preview": "use crate::{\n    context::{Context, Cx},\n    handle::Handle,\n    result::{JsResult, NeonResult},\n    types::{\n        ex"
  },
  {
    "path": "crates/neon/src/types_impl/extract/buffer.rs",
    "chars": 5451,
    "preview": "use crate::{\n    context::Cx,\n    handle::Handle,\n    result::{JsResult, NeonResult},\n    types::{\n        buffer::{Bina"
  },
  {
    "path": "crates/neon/src/types_impl/extract/container.rs",
    "chars": 3627,
    "preview": "use std::{\n    cell::{Ref, RefCell, RefMut},\n    rc::Rc,\n    sync::{Arc, LazyLock},\n};\n\nuse crate::{\n    context::{Conte"
  },
  {
    "path": "crates/neon/src/types_impl/extract/either.rs",
    "chars": 2591,
    "preview": "use std::{any, error, fmt};\n\nuse either::Either;\n\nuse crate::{\n    context::Cx,\n    handle::Handle,\n    object::Object,\n"
  },
  {
    "path": "crates/neon/src/types_impl/extract/error.rs",
    "chars": 4245,
    "preview": "use std::{convert::Infallible, error, fmt, marker::PhantomData};\n\nuse crate::{\n    context::{Context, Cx},\n    result::J"
  },
  {
    "path": "crates/neon/src/types_impl/extract/json.rs",
    "chars": 4374,
    "preview": "//! Extract JavaScript values with JSON serialization\n//!\n//! For complex objects that implement [`serde::Serialize`] an"
  },
  {
    "path": "crates/neon/src/types_impl/extract/mod.rs",
    "chars": 10804,
    "preview": "//! Traits and utilities for extract Rust data from JavaScript values.\n//!\n//! The full list of included extractors can "
  },
  {
    "path": "crates/neon/src/types_impl/extract/private.rs",
    "chars": 1308,
    "preview": "use std::{\n    cell::{Ref, RefCell, RefMut},\n    rc::Rc,\n    sync::Arc,\n};\n\nuse crate::{\n    context::FunctionContext,\n "
  },
  {
    "path": "crates/neon/src/types_impl/extract/try_from_js.rs",
    "chars": 7383,
    "preview": "// Implementations in this file are equivalent to a call to `.downcast()` and\n// `.value(&mut cx)`. These specialized ve"
  },
  {
    "path": "crates/neon/src/types_impl/extract/try_into_js.rs",
    "chars": 3355,
    "preview": "use crate::{\n    context::{Context, Cx},\n    handle::{Handle, Root},\n    object::Object,\n    result::{JsResult, Throw},\n"
  },
  {
    "path": "crates/neon/src/types_impl/extract/with.rs",
    "chars": 1644,
    "preview": "use crate::{\n    context::Cx,\n    result::JsResult,\n    types::{extract::TryIntoJs, Value},\n};\n\nstruct With<F>(pub F);\n\n"
  },
  {
    "path": "crates/neon/src/types_impl/function/mod.rs",
    "chars": 12063,
    "preview": "//! Types and traits for working with JavaScript functions.\n\nuse smallvec::smallvec;\n\nuse crate::{\n    context::{Context"
  },
  {
    "path": "crates/neon/src/types_impl/function/private.rs",
    "chars": 479,
    "preview": "use smallvec::SmallVec;\n\nuse crate::{context::Cx, handle::Handle, result::NeonResult, types::JsValue};\n\npub type ArgsVec"
  },
  {
    "path": "crates/neon/src/types_impl/mod.rs",
    "chars": 38706,
    "preview": "// See types_docs.rs for top-level module API docs.\n\n#[cfg(feature = \"napi-6\")]\n#[cfg_attr(docsrs, doc(cfg(feature = \"na"
  },
  {
    "path": "crates/neon/src/types_impl/private.rs",
    "chars": 3751,
    "preview": "use std::{ffi::c_void, mem::MaybeUninit};\n\nuse crate::{\n    context::{\n        internal::{ContextInternal, Env},\n       "
  },
  {
    "path": "crates/neon/src/types_impl/promise.rs",
    "chars": 20248,
    "preview": "use std::ptr;\n\nuse crate::{\n    context::{\n        internal::{ContextInternal, Env},\n        Context, Cx,\n    },\n    han"
  },
  {
    "path": "crates/neon/src/types_impl/utf8.rs",
    "chars": 1573,
    "preview": "use std::borrow::Cow;\n\nconst SMALL_MAX: usize = i32::MAX as usize;\n\n/// V8 APIs that take UTF-8 strings take their lengt"
  },
  {
    "path": "crates/neon-macros/Cargo.toml",
    "chars": 378,
    "preview": "[package]\nname = \"neon-macros\"\nversion = \"1.1.1\"\nauthors = [\"Dave Herman <david.herman@gmail.com>\"]\ndescription = \"Proce"
  },
  {
    "path": "crates/neon-macros/LICENSE-APACHE",
    "chars": 10847,
    "preview": "                              Apache License\n                        Version 2.0, January 2004\n                     http"
  },
  {
    "path": "crates/neon-macros/LICENSE-MIT",
    "chars": 1056,
    "preview": "Copyright (c) 2015 David Herman\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this so"
  },
  {
    "path": "crates/neon-macros/src/class/meta.rs",
    "chars": 3129,
    "preview": "#[derive(Default)]\npub(crate) struct Meta {\n    pub(super) kind: Kind,\n    pub(super) name: Option<syn::LitStr>,\n    pub"
  },
  {
    "path": "crates/neon-macros/src/class/mod.rs",
    "chars": 51042,
    "preview": "mod meta;\n\nuse super::name::is_valid_js_identifier;\nuse proc_macro2::TokenStream;\nuse syn::{spanned::Spanned, Ident, Imp"
  },
  {
    "path": "crates/neon-macros/src/export/class/meta.rs",
    "chars": 3124,
    "preview": "use syn::parse::{Parse, ParseStream};\n\n/// Metadata for class exports\n#[derive(Default)]\npub(crate) struct Meta {\n    //"
  },
  {
    "path": "crates/neon-macros/src/export/class.rs",
    "chars": 3511,
    "preview": "use proc_macro2::TokenStream;\nuse quote::quote;\nuse syn::spanned::Spanned;\n\npub(crate) mod meta;\n\npub(super) fn export(m"
  },
  {
    "path": "crates/neon-macros/src/export/function/meta.rs",
    "chars": 2603,
    "preview": "#[derive(Default)]\npub(crate) struct Meta {\n    pub(super) kind: Kind,\n    pub(super) name: Option<syn::LitStr>,\n    pub"
  },
  {
    "path": "crates/neon-macros/src/export/function/mod.rs",
    "chars": 12489,
    "preview": "use syn::spanned::Spanned;\n\nuse crate::export::function::meta::Kind;\n\npub(crate) mod meta;\n\npub(super) fn export(meta: m"
  },
  {
    "path": "crates/neon-macros/src/export/global/meta.rs",
    "chars": 790,
    "preview": "#[derive(Default)]\npub(crate) struct Meta {\n    pub(super) name: Option<syn::LitStr>,\n    pub(super) json: bool,\n}\n\npub("
  },
  {
    "path": "crates/neon-macros/src/export/global/mod.rs",
    "chars": 2361,
    "preview": "pub(crate) mod meta;\n\n// Create a new block expression for the RHS of an assignment\npub(super) fn export(meta: meta::Met"
  },
  {
    "path": "crates/neon-macros/src/export/mod.rs",
    "chars": 1893,
    "preview": "mod class;\nmod function;\nmod global;\n\n// N.B.: Meta attribute parsing happens in this function because `syn::parse_macro"
  },
  {
    "path": "crates/neon-macros/src/lib.rs",
    "chars": 1275,
    "preview": "//! Procedural macros supporting [Neon](https://docs.rs/neon/latest/neon/)\n\nmod class;\nmod export;\npub(crate) mod name;\n"
  },
  {
    "path": "crates/neon-macros/src/name.rs",
    "chars": 4439,
    "preview": "// Convert identifiers to camel case with the following rules:\n// * All leading and trailing underscores are preserved\n/"
  },
  {
    "path": "doc/MIGRATION_GUIDE_0.10.md",
    "chars": 9298,
    "preview": "# Neon 0.10 Migration Guide\n\nWith the API improvements of Neon 0.10, a few backwards-incompatible changes have been intr"
  },
  {
    "path": "doc/MIGRATION_GUIDE_1.0.0.md",
    "chars": 3388,
    "preview": "# Neon 1.0.0 Migration Guide\n\n> **Note:** This migration guide assumes a project is using Neon 0.10 without Node-API bac"
  },
  {
    "path": "doc/MIGRATION_GUIDE_NAPI.md",
    "chars": 11255,
    "preview": "# N-API Migration Guide\n\n## What is this about?\n\nSince v10, Node.js supports an improved API for building native modules"
  },
  {
    "path": "package.json",
    "chars": 446,
    "preview": "{\n  \"name\": \"neon-workspace\",\n  \"private\": true,\n  \"scripts\": {\n    \"prettier\": \"prettier -w \\\"**/*.{js,json,ts,yml}\\\"\","
  },
  {
    "path": "pkgs/cargo-cp-artifact/LICENSE",
    "chars": 1073,
    "preview": "MIT License\n\nCopyright (c) 2021 The Neon Project\n\nPermission is hereby granted, free of charge, to any person obtaining "
  },
  {
    "path": "pkgs/cargo-cp-artifact/README.md",
    "chars": 3128,
    "preview": "# cargo-cp-artifact\n\n`cargo-cp-artifact` is a small command line utility for parsing cargo metadata output and copying a"
  },
  {
    "path": "pkgs/cargo-cp-artifact/bin/cargo-cp-artifact.js",
    "chars": 104,
    "preview": "#!/usr/bin/env node\n\"use strict\";\n\nconst run = require(\"..\");\n\nrun(process.argv.slice(2), process.env);\n"
  },
  {
    "path": "pkgs/cargo-cp-artifact/package.json",
    "chars": 744,
    "preview": "{\n  \"name\": \"cargo-cp-artifact\",\n  \"version\": \"0.1.9\",\n  \"description\": \"Copies compiler artifacts emitted by rustc by p"
  },
  {
    "path": "pkgs/cargo-cp-artifact/src/args.js",
    "chars": 2884,
    "preview": "\"use strict\";\n\nclass ParseError extends Error {}\n\nconst NPM_ENV = \"npm_package_name\";\nconst EXPECTED_COMMAND = [\n  \"Miss"
  },
  {
    "path": "pkgs/cargo-cp-artifact/src/index.js",
    "chars": 4359,
    "preview": "\"use strict\";\n\nconst { spawn } = require(\"child_process\");\nconst {\n  promises: { copyFile, mkdir, stat, unlink },\n} = re"
  },
  {
    "path": "pkgs/cargo-cp-artifact/test/args.js",
    "chars": 3243,
    "preview": "\"use strict\";\n\nconst assert = require(\"assert\");\n\nconst { parse } = require(\"../src/args\");\n\ndescribe(\"Argument Parsing\""
  },
  {
    "path": "pkgs/create-neon/.mocharc.json",
    "chars": 76,
    "preview": "{\n  \"extension\": [\"ts\"],\n  \"spec\": \"dist/test/**/*.js\",\n  \"timeout\": 5000\n}\n"
  },
  {
    "path": "pkgs/create-neon/README.md",
    "chars": 2708,
    "preview": "# Create Neon\n\nThe `create-neon` tool bootstraps [Neon](https://neon-bindings.com) projects, which allows developers to "
  },
  {
    "path": "pkgs/create-neon/data/templates/.gitignore.hbs",
    "chars": 135,
    "preview": "target\nindex.node\n**/node_modules\n**/.DS_Store\nnpm-debug.log*{{#eq options.library.lang compare=\"ts\"}}\nlib\n{{/eq}}\ncargo"
  },
  {
    "path": "pkgs/create-neon/data/templates/Cargo.toml.hbs",
    "chars": 500,
    "preview": "[package]\nname = {{crate.escaped.name}}\nversion = {{crate.escaped.version}}\n{{#if crate.description}}\ndescription = {{cr"
  },
  {
    "path": "pkgs/create-neon/data/templates/README.md.hbs",
    "chars": 5820,
    "preview": "# {{package.name}}\n\n{{#if package.description}}\n**{{package.name}}:** {{package.description}}\n\n{{/if}}\nThis project was "
  },
  {
    "path": "pkgs/create-neon/data/templates/Workspace.toml.hbs",
    "chars": 63,
    "preview": "[workspace]\nmembers = [\"crates/{{crate.name}}\"]\nresolver = \"3\"\n"
  },
  {
    "path": "pkgs/create-neon/data/templates/ci/github/build.yml.hbs",
    "chars": 4684,
    "preview": "name: Build\n\non:\n  workflow_call:\n    inputs:\n      ref:\n        description: 'The branch, tag, or SHA to check out'\n   "
  },
  {
    "path": "pkgs/create-neon/data/templates/ci/github/release.yml.hbs",
    "chars": 4783,
    "preview": "name: Release\n\nrun-name: |\n  {{#$}} (inputs.dryrun && 'Dry run')\n   || format('Release: {0}', (inputs.version == 'custom"
  },
  {
    "path": "pkgs/create-neon/data/templates/ci/github/setup.yml.hbs",
    "chars": 2535,
    "preview": "name: 'Setup Neon'\ndescription: 'Setup the Neon toolchain.'\ninputs:\n  platform:\n    description: 'Platform being built f"
  },
  {
    "path": "pkgs/create-neon/data/templates/ci/github/test.yml.hbs",
    "chars": 2294,
    "preview": "name: Test\n\nrun-name: |\n  {{#$}} (github.event_name == 'pull_request' && format('Test (PR #{0}): {1}', github.event.numb"
  },
  {
    "path": "pkgs/create-neon/data/templates/lib.rs.hbs",
    "chars": 484,
    "preview": "// Use #[neon::export] to export Rust functions as JavaScript functions.\n// See more at: https://docs.rs/neon/latest/neo"
  },
  {
    "path": "pkgs/create-neon/data/templates/manifest/base/default.json.hbs",
    "chars": 416,
    "preview": "\n{\n  \"name\": \"{{options.fullName}}\",\n  \"version\": \"{{options.version}}\",\n  \"main\": \"index.node\",\n  \"scripts\": {},\n  \"dev"
  },
  {
    "path": "pkgs/create-neon/data/templates/manifest/base/library.json.hbs",
    "chars": 1195,
    "preview": "\n{\n  \"name\": \"{{options.fullName}}\",\n  \"version\": \"{{options.version}}\",\n{{#eq options.library.module compare=\"esm\"}}\n  "
  },
  {
    "path": "pkgs/create-neon/data/templates/ts/index.cts.hbs",
    "chars": 450,
    "preview": "// This module is the CJS entry point for the library.\n\n// The Rust addon.\nimport * as addon from './load.cjs';\n\n// Use "
  },
  {
    "path": "pkgs/create-neon/data/templates/ts/index.mts.hbs",
    "chars": 85,
    "preview": "// This module is the ESM entry point for the library.\n\nexport * from './index.cjs';\n"
  },
  {
    "path": "pkgs/create-neon/data/templates/ts/load.cts.hbs",
    "chars": 378,
    "preview": "// This module loads the platform-specific build of the addon on\n// the current system. The supported platforms are regi"
  },
  {
    "path": "pkgs/create-neon/data/templates/tsconfig.json.hbs",
    "chars": 363,
    "preview": "{\n{{#eq options.library.lang compare=\"ts\"}}\n  \"extends\": \"@tsconfig/node{{versions.tsconfigNode.major}}/tsconfig.json\",\n"
  },
  {
    "path": "pkgs/create-neon/data/versions.json",
    "chars": 822,
    "preview": "{\n  \"neon\": \"1.1\",\n  \"neonCLI\": \"0.1.82\",\n  \"neonLoad\": \"0.1.82\",\n  \"typescript\": \"5.3.3\",\n  \"typesNode\": \"20.11.16\",\n  "
  },
  {
    "path": "pkgs/create-neon/dev/expect.ts",
    "chars": 5185,
    "preview": "import { ChildProcess } from \"child_process\";\nimport { Readable, Writable } from \"stream\";\nimport readStream from \"strea"
  },
  {
    "path": "pkgs/create-neon/package.json",
    "chars": 1822,
    "preview": "{\n  \"name\": \"create-neon\",\n  \"version\": \"0.7.0\",\n  \"description\": \"Create Neon projects with no build configuration.\",\n "
  },
  {
    "path": "pkgs/create-neon/src/bin/create-neon.ts",
    "chars": 5024,
    "preview": "#!/usr/bin/env node\n\nimport commandLineArgs from \"command-line-args\";\nimport { printErrorWithUsage } from \"../print.js\";"
  },
  {
    "path": "pkgs/create-neon/src/cache/npm.ts",
    "chars": 257,
    "preview": "import { Cache } from \"../cache.js\";\n\nexport class NPM implements Cache {\n  readonly org: string;\n  readonly prefix: str"
  },
  {
    "path": "pkgs/create-neon/src/cache.ts",
    "chars": 52,
    "preview": "export interface Cache {\n  readonly type: string;\n}\n"
  },
  {
    "path": "pkgs/create-neon/src/ci/github.ts",
    "chars": 1080,
    "preview": "import handlebars from \"handlebars\";\nimport { CI } from \"../ci.js\";\nimport path from \"node:path\";\n\nconst TEMPLATES: Reco"
  },
  {
    "path": "pkgs/create-neon/src/ci.ts",
    "chars": 142,
    "preview": "export interface CI {\n  readonly type: string;\n  templates(): Record<string, string>;\n  setup(): void;\n  scripts(): Reco"
  },
  {
    "path": "pkgs/create-neon/src/create/app.ts",
    "chars": 697,
    "preview": "import { Creator, ProjectOptions } from \"./creator.js\";\n\nexport class AppCreator extends Creator {\n  constructor(options"
  },
  {
    "path": "pkgs/create-neon/src/create/creator.ts",
    "chars": 4593,
    "preview": "import die from \"../die.js\";\nimport { mktemp } from \"../fs.js\";\nimport * as path from \"node:path\";\nimport * as fs from \""
  },
  {
    "path": "pkgs/create-neon/src/create/lib.ts",
    "chars": 3699,
    "preview": "import { Creator, ProjectOptions, LibraryOptions, Lang } from \"./creator.js\";\nimport { Context } from \"../expand/context"
  },
  {
    "path": "pkgs/create-neon/src/die.ts",
    "chars": 381,
    "preview": "import { promises as fs } from \"fs\";\n\nfunction deleteNeonDir(dir: string): Promise<void> {\n  return fs.rm(dir, { force: "
  },
  {
    "path": "pkgs/create-neon/src/expand/context.ts",
    "chars": 737,
    "preview": "import { ProjectOptions } from \"../create/creator.js\";\nimport { VERSIONS, Versions } from \"./versions.js\";\n\nexport type "
  },
  {
    "path": "pkgs/create-neon/src/expand/index.ts",
    "chars": 955,
    "preview": "import { promises as fs } from \"fs\";\nimport handlebars from \"handlebars\";\nimport helpers from \"handlebars-helpers\";\nimpo"
  },
  {
    "path": "pkgs/create-neon/src/expand/versions.ts",
    "chars": 1932,
    "preview": "// This whole module is a bummer but was the best I could figure out since:\n// - Using @sindresorhus packages like 'chal"
  },
  {
    "path": "pkgs/create-neon/src/fs.ts",
    "chars": 891,
    "preview": "import * as fs from \"node:fs/promises\";\nimport * as path from \"node:path\";\nimport { existsSync, rmSync } from \"node:fs\";"
  },
  {
    "path": "pkgs/create-neon/src/index.ts",
    "chars": 4035,
    "preview": "import { Context } from \"./expand/context.js\";\nimport {\n  NodePlatform,\n  PlatformPreset,\n  isNodePlatform,\n  isPlatform"
  },
  {
    "path": "pkgs/create-neon/src/print.ts",
    "chars": 2911,
    "preview": "import commandLineUsage from \"command-line-usage\";\nimport chalk from \"chalk\";\n\nfunction pink(text: string): string {\n  r"
  },
  {
    "path": "pkgs/create-neon/src/shell.ts",
    "chars": 5344,
    "preview": "import { ChildProcess, spawn } from \"node:child_process\";\nimport { PassThrough, Readable, Writable } from \"node:stream\";"
  },
  {
    "path": "pkgs/create-neon/test/create-neon.ts",
    "chars": 6965,
    "preview": "import { assert } from \"chai\";\nimport { spawn } from \"child_process\";\nimport * as path from \"path\";\nimport { promises as"
  },
  {
    "path": "pkgs/create-neon/tsconfig.json",
    "chars": 313,
    "preview": "{\n  \"extends\": \"@tsconfig/node18/tsconfig.json\",\n  \"compilerOptions\": {\n    \"module\": \"es2022\",\n    \"moduleResolution\": "
  },
  {
    "path": "test/electron/Cargo.toml",
    "chars": 208,
    "preview": "[package]\nname = \"electron-tests\"\nversion = \"0.1.0\"\nedition = \"2021\"\nauthors = [\"The Neon Community\"]\nlicense = \"MIT/Apa"
  },
  {
    "path": "test/electron/README.md",
    "chars": 234,
    "preview": "# neon-electron-quick-start\n\nThis is a minimal Electron application based on the [Quick Start Guide](https://electronjs."
  },
  {
    "path": "test/electron/index.html",
    "chars": 535,
    "preview": "<!DOCTYPE html>\n<html>\n  <head>\n    <meta charset=\"UTF-8\">\n    <!-- https://developer.mozilla.org/en-US/docs/Web/HTTP/CS"
  },
  {
    "path": "test/electron/main.js",
    "chars": 1145,
    "preview": "// Modules to control application life and create native browser window\nconst { app, BrowserWindow } = require(\"electron"
  },
  {
    "path": "test/electron/main.test.js",
    "chars": 479,
    "preview": "\"use strict\";\n\nconst assert = require(\"assert\");\nconst path = require(\"path\");\n\nconst { _electron: electron } = require("
  },
  {
    "path": "test/electron/package.json",
    "chars": 593,
    "preview": "{\n  \"name\": \"electron-tests\",\n  \"version\": \"0.1.0\",\n  \"description\": \"Electron acceptance test suite for Neon\",\n  \"main\""
  },
  {
    "path": "test/electron/preload.js",
    "chars": 163,
    "preview": "const native = require(\"./index.node\");\n\nwindow.addEventListener(\"DOMContentLoaded\", () => {\n  document.getElementById(\""
  },
  {
    "path": "test/electron/renderer.js",
    "chars": 293,
    "preview": "// This file is required by the index.html file and will\n// be executed in the renderer process for that window.\n// No N"
  },
  {
    "path": "test/electron/src/lib.rs",
    "chars": 239,
    "preview": "use neon::prelude::*;\n\nfn hello(mut cx: FunctionContext) -> JsResult<JsString> {\n    Ok(cx.string(\"Hello, World!\"))\n}\n\n#"
  },
  {
    "path": "test/napi/.gitignore",
    "chars": 89,
    "preview": "native/target\nnative/index.node\nnative/artifacts.json\n**/*~\n**/node_modules\n**/.DS_Store\n"
  },
  {
    "path": "test/napi/Cargo.toml",
    "chars": 537,
    "preview": "[package]\nname = \"napi-tests\"\nversion = \"0.1.0\"\nauthors = [\"The Neon Community <david.herman@gmail.com>\"]\nlicense = \"MIT"
  },
  {
    "path": "test/napi/README.md",
    "chars": 58,
    "preview": "# napi\n\nAcceptance test suite for Neon with N-API backend\n"
  },
  {
    "path": "test/napi/lib/arrays.js",
    "chars": 755,
    "preview": "var addon = require(\"..\");\nvar assert = require(\"chai\").assert;\n\ndescribe(\"JsArray\", function () {\n  it(\"return a JsArra"
  },
  {
    "path": "test/napi/lib/bigint.js",
    "chars": 168,
    "preview": "const addon = require(\"..\");\n\ndescribe(\"JsBigInt\", () => {\n  const suite = addon.bigint_suite();\n\n  for (const [k, v] of"
  },
  {
    "path": "test/napi/lib/boxed.js",
    "chars": 1795,
    "preview": "const addon = require(\"..\");\nconst { expect } = require(\"chai\");\nconst assert = require(\"chai\").assert;\n\nclass Person {\n"
  },
  {
    "path": "test/napi/lib/class.js",
    "chars": 27976,
    "preview": "const addon = require(\"..\");\nconst assert = require(\"chai\").assert;\n\ndescribe(\"wrapping\", function () {\n  it(\"should be "
  },
  {
    "path": "test/napi/lib/coercions.js",
    "chars": 348,
    "preview": "var addon = require(\"..\");\nvar assert = require(\"chai\").assert;\n\ndescribe(\"coercions\", function () {\n  it(\"can stringify"
  },
  {
    "path": "test/napi/lib/container.js",
    "chars": 2455,
    "preview": "const addon = require(\"..\");\nconst { expect } = require(\"chai\");\nconst assert = require(\"chai\").assert;\n\ndescribe(\"Conta"
  },
  {
    "path": "test/napi/lib/date.js",
    "chars": 1159,
    "preview": "var addon = require(\"..\");\nvar assert = require(\"chai\").assert;\n\ndescribe(\"JsDate\", function () {\n  it(\"should create a "
  },
  {
    "path": "test/napi/lib/errors.js",
    "chars": 1174,
    "preview": "const addon = require(\"..\");\nconst assert = require(\"chai\").assert;\n\ndescribe(\"errors\", function () {\n  it(\"should be ab"
  },
  {
    "path": "test/napi/lib/export.js",
    "chars": 6605,
    "preview": "const assert = require(\"assert\");\n\nconst addon = require(\"..\");\n\ndescribe(\"neon::export macro\", () => {\n  describe(\"glob"
  },
  {
    "path": "test/napi/lib/extract.js",
    "chars": 2956,
    "preview": "const assert = require(\"assert\");\n\nconst addon = require(\"..\");\n\ndescribe(\"Extractors\", () => {\n  it(\"Single Argument\", "
  },
  {
    "path": "test/napi/lib/functions.js",
    "chars": 10949,
    "preview": "var addon = require(\"..\");\nvar assert = require(\"chai\").assert;\n\nconst STRICT = function () {\n  \"use strict\";\n  return t"
  },
  {
    "path": "test/napi/lib/futures.js",
    "chars": 2859,
    "preview": "const assert = require(\"assert\");\n\nconst addon = require(\"..\");\n\nasync function assertRejects(f, ...args) {\n  try {\n    "
  },
  {
    "path": "test/napi/lib/hello.js",
    "chars": 981,
    "preview": "var addon = require(\"..\");\nvar assert = require(\"chai\").assert;\n\ndescribe(\"hello\", function () {\n  it(\"should export a g"
  },
  {
    "path": "test/napi/lib/numbers.js",
    "chars": 1834,
    "preview": "var addon = require(\"..\");\nvar assert = require(\"chai\").assert;\n\ndescribe(\"JsNumber\", function () {\n  it(\"return a JsNum"
  },
  {
    "path": "test/napi/lib/objects.js",
    "chars": 4459,
    "preview": "var addon = require(\"..\");\nvar assert = require(\"chai\").assert;\n\ndescribe(\"JsObject\", function () {\n  it(\"return the v8:"
  },
  {
    "path": "test/napi/lib/strings.js",
    "chars": 1295,
    "preview": "var addon = require(\"..\");\nvar { assert, expect } = require(\"chai\");\n\ndescribe(\"JsString\", function () {\n  it(\"should re"
  },
  {
    "path": "test/napi/lib/threads.js",
    "chars": 14386,
    "preview": "const addon = require(\"..\");\nconst assert = require(\"chai\").assert;\n\n(function () {\n  // These tests require GC exposed "
  },
  {
    "path": "test/napi/lib/typedarrays.js",
    "chars": 18580,
    "preview": "var addon = require(\"..\");\nvar assert = require(\"chai\").assert;\n\nconst { Worker, isMainThread, parentPort } = require(\"w"
  },
  {
    "path": "test/napi/lib/types.js",
    "chars": 2915,
    "preview": "var addon = require(\"..\");\nvar assert = require(\"chai\").assert;\n\ndescribe(\"type checks\", function () {\n  it(\"is_array\", "
  },
  {
    "path": "test/napi/lib/workers.js",
    "chars": 6275,
    "preview": "const assert = require(\"assert\");\nconst {\n  Worker,\n  isMainThread,\n  parentPort,\n  threadId,\n  workerData,\n} = require("
  },
  {
    "path": "test/napi/package.json",
    "chars": 497,
    "preview": "{\n  \"name\": \"napi-tests\",\n  \"version\": \"0.1.0\",\n  \"description\": \"Acceptance test suite for Neon with N-API backend\",\n  "
  },
  {
    "path": "test/napi/src/js/arrays.rs",
    "chars": 762,
    "preview": "use neon::prelude::*;\n\npub fn return_js_array(mut cx: FunctionContext) -> JsResult<JsArray> {\n    Ok(cx.empty_array())\n}"
  },
  {
    "path": "test/napi/src/js/bigint.rs",
    "chars": 14618,
    "preview": "/// Tests for [`JsBigInt`]. All unit tests are prefixed with `test_` and exported by\n/// [`bigint_suite`].\nuse std::{any"
  },
  {
    "path": "test/napi/src/js/boxed.rs",
    "chars": 2287,
    "preview": "use std::cell::RefCell;\n\nuse neon::{prelude::*, types::extract::Boxed};\n\npub struct Person {\n    name: String,\n}\n\nimpl F"
  },
  {
    "path": "test/napi/src/js/class.rs",
    "chars": 15449,
    "preview": "use std::{collections::HashMap, future::Future};\n\nuse neon::{event::Channel, prelude::*, types::extract::Json};\n\n#[neon:"
  }
]

// ... and 80 more files (download for full content)