use std::any::TypeId;

use std::cell::{RefCell, UnsafeCell};

use std::ffi::{CStr, CString};

use std::fmt;

use std::marker::PhantomData;

use std::mem::{self, MaybeUninit};

use std::ops::Deref;

use std::os::raw::{c_char, c_int, c_void};

use std::panic::{catch_unwind, resume_unwind, AssertUnwindSafe, Location};

use std::ptr;

use std::result::Result as StdResult;

use std::sync::atomic::{AtomicPtr, Ordering};

use std::sync::{Arc, Mutex};

use rustc_hash::FxHashMap;

use crate::chunk::{AsChunk, Chunk, ChunkMode};

use crate::error::{Error, Result};

use crate::function::Function;

use crate::hook::Debug;

use crate::memory::{MemoryState, ALLOCATOR};

use crate::scope::Scope;

use crate::stdlib::StdLib;

use crate::string::String;

use crate::table::Table;

use crate::thread::Thread;

use crate::types::{

AppData, AppDataRef, AppDataRefMut, Callback, CallbackUpvalue, DestructedUserdata, Integer,

LightUserData, LuaRef, MaybeSend, Number, RegistryKey, SubtypeId,

use crate::userdata::{AnyUserData, MetaMethod, UserData, UserDataCell};

use crate::userdata_impl::{UserDataProxy, UserDataRegistry};

use crate::util::{

self, assert_stack, check_stack, error_traceback, get_destructed_userdata_metatable,

get_gc_metatable, get_gc_userdata, get_main_state, get_userdata, init_error_registry,

init_gc_metatable, init_userdata_metatable, pop_error, push_gc_userdata, push_string,

push_table, rawset_field, safe_pcall, safe_xpcall, short_type_name, StackGuard, WrappedFailure,

use crate::value::{FromLua, FromLuaMulti, IntoLua, IntoLuaMulti, MultiValue, Nil, Value};

use crate::util::push_userdata;

use crate::{types::WarnCallback, userdata::USER_VALUE_MAXSLOT, util::push_userdata_uv};

use crate::{hook::HookTriggers, types::HookCallback};

use crate::types::InterruptCallback;

use crate::{

chunk::Compiler,

types::{Vector, VmState},

use {

crate::types::{AsyncCallback, AsyncCallbackUpvalue, AsyncPollUpvalue},

futures_util::future::{self, Future},

futures_util::task::{noop_waker_ref, Context, Poll, Waker},

std::ptr::NonNull,

use serde::Serialize;

pub struct Lua(Arc<LuaInner>);

pub struct LuaInner {

pub(crate) struct ExtraData {

pub enum GCMode {

pub struct LuaOptions {

impl Default for LuaOptions {

impl LuaOptions {

pub(crate) static ASYNC_POLL_PENDING: u8 = 0;

pub(crate) static EXTRA_REGISTRY_KEY: u8 = 0;

const WRAPPED_FAILURE_POOL_SIZE: usize = 64;

const MULTIVALUE_POOL_SIZE: usize = 64;

const REF_STACK_RESERVE: c_int = 1;

unsafe impl Send for Lua {}

unsafe impl Sync for Lua {}

impl Drop for Lua {

impl Drop for LuaInner {

impl Drop for ExtraData {

impl fmt::Debug for Lua {

impl Deref for Lua {

impl Default for Lua {

impl Lua {