
#This File auto generated
use strict;
use warnings;

=over

=cut

=item C<alloc>

see L<http://duktape.org/api.html#duk_alloc>

=cut
*alloc = \&aperl_duk_alloc;

=item C<alloc_raw>

see L<http://duktape.org/api.html#duk_alloc_raw>

=cut
*alloc_raw = \&aperl_duk_alloc_raw;

=item C<base64_decode>

see L<http://duktape.org/api.html#duk_base64_decode>

=cut
*base64_decode = \&aperl_duk_base64_decode;

=item C<base64_encode>

see L<http://duktape.org/api.html#duk_base64_encode>

=cut
*base64_encode = \&aperl_duk_base64_encode;

=item C<buffer_to_string>

see L<http://duktape.org/api.html#duk_buffer_to_string>

=cut
*buffer_to_string = \&aperl_duk_buffer_to_string;

=item C<call>

see L<http://duktape.org/api.html#duk_call>

=cut
*call = \&aperl_duk_call;

=item C<call_method>

see L<http://duktape.org/api.html#duk_call_method>

=cut
*call_method = \&aperl_duk_call_method;

=item C<call_prop>

see L<http://duktape.org/api.html#duk_call_prop>

=cut
*call_prop = \&aperl_duk_call_prop;

=item C<char_code_at>

see L<http://duktape.org/api.html#duk_char_code_at>

=cut
*char_code_at = \&aperl_duk_char_code_at;

=item C<check_stack>

see L<http://duktape.org/api.html#duk_check_stack>

=cut
*check_stack = \&aperl_duk_check_stack;

=item C<check_stack_top>

see L<http://duktape.org/api.html#duk_check_stack_top>

=cut
*check_stack_top = \&aperl_duk_check_stack_top;

=item C<check_type>

see L<http://duktape.org/api.html#duk_check_type>

=cut
*check_type = \&aperl_duk_check_type;

=item C<check_type_mask>

see L<http://duktape.org/api.html#duk_check_type_mask>

=cut
*check_type_mask = \&aperl_duk_check_type_mask;

=item C<compact>

see L<http://duktape.org/api.html#duk_compact>

=cut
*compact = \&aperl_duk_compact;

=item C<compile>

see L<http://duktape.org/api.html#duk_compile>

=cut
*compile = \&aperl_duk_compile;

=item C<compile_lstring>

see L<http://duktape.org/api.html#duk_compile_lstring>

=cut
*compile_lstring = \&aperl_duk_compile_lstring;

=item C<compile_lstring_filename>

see L<http://duktape.org/api.html#duk_compile_lstring_filename>

=cut
*compile_lstring_filename = \&aperl_duk_compile_lstring_filename;

=item C<compile_string>

see L<http://duktape.org/api.html#duk_compile_string>

=cut
*compile_string = \&aperl_duk_compile_string;

=item C<compile_string_filename>

see L<http://duktape.org/api.html#duk_compile_string_filename>

=cut
*compile_string_filename = \&aperl_duk_compile_string_filename;

=item C<components_to_time>

see L<http://duktape.org/api.html#duk_components_to_time>

=cut
*components_to_time = \&aperl_duk_components_to_time;

=item C<concat>

see L<http://duktape.org/api.html#duk_concat>

=cut
*concat = \&aperl_duk_concat;

=item C<config_buffer>

see L<http://duktape.org/api.html#duk_config_buffer>

=cut
*config_buffer = \&aperl_duk_config_buffer;

=item C<copy>

see L<http://duktape.org/api.html#duk_copy>

=cut
*copy = \&aperl_duk_copy;

=item C<decode_string>

see L<http://duktape.org/api.html#duk_decode_string>

=cut
*decode_string = \&aperl_duk_decode_string;

=item C<def_prop>

see L<http://duktape.org/api.html#duk_def_prop>

=cut
*def_prop = \&aperl_duk_def_prop;

=item C<del_prop>

see L<http://duktape.org/api.html#duk_del_prop>

=cut
*del_prop = \&aperl_duk_del_prop;

=item C<del_prop_heapptr>

see L<http://duktape.org/api.html#duk_del_prop_heapptr>

=cut
*del_prop_heapptr = \&aperl_duk_del_prop_heapptr;

=item C<del_prop_index>

see L<http://duktape.org/api.html#duk_del_prop_index>

=cut
*del_prop_index = \&aperl_duk_del_prop_index;

=item C<del_prop_lstring>

see L<http://duktape.org/api.html#duk_del_prop_lstring>

=cut
*del_prop_lstring = \&aperl_duk_del_prop_lstring;

=item C<del_prop_string>

see L<http://duktape.org/api.html#duk_del_prop_string>

=cut
*del_prop_string = \&aperl_duk_del_prop_string;

=item C<destroy_heap>

see L<http://duktape.org/api.html#duk_destroy_heap>

=cut
*destroy_heap = \&aperl_duk_destroy_heap;

=item C<dump_function>

see L<http://duktape.org/api.html#duk_dump_function>

=cut
*dump_function = \&aperl_duk_dump_function;

=item C<dup>

see L<http://duktape.org/api.html#duk_dup>

=cut
*dup = \&aperl_duk_dup;

=item C<dup_top>

see L<http://duktape.org/api.html#duk_dup_top>

=cut
*dup_top = \&aperl_duk_dup_top;

=item C<enum>

see L<http://duktape.org/api.html#duk_enum>

=cut
*enum = \&aperl_duk_enum;

=item C<equals>

see L<http://duktape.org/api.html#duk_equals>

=cut
*equals = \&aperl_duk_equals;

=item C<error_va>

see L<http://duktape.org/api.html#duk_error_va>

=cut
*error_va = \&aperl_duk_error_va;

=item C<eval>

see L<http://duktape.org/api.html#duk_eval>

=cut
*eval = \&aperl_duk_eval;

=item C<eval_error_va>

see L<http://duktape.org/api.html#duk_eval_error_va>

=cut
*eval_error_va = \&aperl_duk_eval_error_va;

=item C<eval_lstring>

see L<http://duktape.org/api.html#duk_eval_lstring>

=cut
*eval_lstring = \&aperl_duk_eval_lstring;

=item C<eval_lstring_noresult>

see L<http://duktape.org/api.html#duk_eval_lstring_noresult>

=cut
*eval_lstring_noresult = \&aperl_duk_eval_lstring_noresult;

=item C<eval_noresult>

see L<http://duktape.org/api.html#duk_eval_noresult>

=cut
*eval_noresult = \&aperl_duk_eval_noresult;

=item C<eval_string>

see L<http://duktape.org/api.html#duk_eval_string>

=cut
*eval_string = \&aperl_duk_eval_string;

=item C<eval_string_noresult>

see L<http://duktape.org/api.html#duk_eval_string_noresult>

=cut
*eval_string_noresult = \&aperl_duk_eval_string_noresult;

=item C<fatal>

see L<http://duktape.org/api.html#duk_fatal>

=cut
*fatal = \&aperl_duk_fatal;

=item C<free>

see L<http://duktape.org/api.html#duk_free>

=cut
*free = \&aperl_duk_free;

=item C<free_raw>

see L<http://duktape.org/api.html#duk_free_raw>

=cut
*free_raw = \&aperl_duk_free_raw;

=item C<freeze>

see L<http://duktape.org/api.html#duk_freeze>

=cut
*freeze = \&aperl_duk_freeze;

=item C<gc>

see L<http://duktape.org/api.html#duk_gc>

=cut
*gc = \&aperl_duk_gc;

=item C<generic_error_va>

see L<http://duktape.org/api.html#duk_generic_error_va>

=cut
*generic_error_va = \&aperl_duk_generic_error_va;

=item C<get_boolean>

see L<http://duktape.org/api.html#duk_get_boolean>

=cut
*get_boolean = \&aperl_duk_get_boolean;

=item C<get_boolean_default>

see L<http://duktape.org/api.html#duk_get_boolean_default>

=cut
*get_boolean_default = \&aperl_duk_get_boolean_default;

=item C<get_buffer>

see L<http://duktape.org/api.html#duk_get_buffer>

=cut
*get_buffer = \&aperl_duk_get_buffer;

=item C<get_buffer_data>

see L<http://duktape.org/api.html#duk_get_buffer_data>

=cut
*get_buffer_data = \&aperl_duk_get_buffer_data;

=item C<get_buffer_data_default>

see L<http://duktape.org/api.html#duk_get_buffer_data_default>

=cut
*get_buffer_data_default = \&aperl_duk_get_buffer_data_default;

=item C<get_buffer_default>

see L<http://duktape.org/api.html#duk_get_buffer_default>

=cut
*get_buffer_default = \&aperl_duk_get_buffer_default;

=item C<get_c_function>

see L<http://duktape.org/api.html#duk_get_c_function>

=cut
*get_c_function = \&aperl_duk_get_c_function;

=item C<get_c_function_default>

see L<http://duktape.org/api.html#duk_get_c_function_default>

=cut
*get_c_function_default = \&aperl_duk_get_c_function_default;

=item C<get_context>

see L<http://duktape.org/api.html#duk_get_context>

=cut
*get_context = \&aperl_duk_get_context;

=item C<get_context_default>

see L<http://duktape.org/api.html#duk_get_context_default>

=cut
*get_context_default = \&aperl_duk_get_context_default;

=item C<get_current_magic>

see L<http://duktape.org/api.html#duk_get_current_magic>

=cut
*get_current_magic = \&aperl_duk_get_current_magic;

=item C<get_error_code>

see L<http://duktape.org/api.html#duk_get_error_code>

=cut
*get_error_code = \&aperl_duk_get_error_code;

=item C<get_finalizer>

see L<http://duktape.org/api.html#duk_get_finalizer>

=cut
*get_finalizer = \&aperl_duk_get_finalizer;

=item C<get_global_lstring>

see L<http://duktape.org/api.html#duk_get_global_lstring>

=cut
*get_global_lstring = \&aperl_duk_get_global_lstring;

=item C<get_global_string>

see L<http://duktape.org/api.html#duk_get_global_string>

=cut
*get_global_string = \&aperl_duk_get_global_string;

=item C<get_heapptr>

see L<http://duktape.org/api.html#duk_get_heapptr>

=cut
*get_heapptr = \&aperl_duk_get_heapptr;

=item C<get_heapptr_default>

see L<http://duktape.org/api.html#duk_get_heapptr_default>

=cut
*get_heapptr_default = \&aperl_duk_get_heapptr_default;

=item C<get_int>

see L<http://duktape.org/api.html#duk_get_int>

=cut
*get_int = \&aperl_duk_get_int;

=item C<get_int_default>

see L<http://duktape.org/api.html#duk_get_int_default>

=cut
*get_int_default = \&aperl_duk_get_int_default;

=item C<get_length>

see L<http://duktape.org/api.html#duk_get_length>

=cut
*get_length = \&aperl_duk_get_length;

=item C<get_lstring>

see L<http://duktape.org/api.html#duk_get_lstring>

=cut
*get_lstring = \&aperl_duk_get_lstring;

=item C<get_lstring_default>

see L<http://duktape.org/api.html#duk_get_lstring_default>

=cut
*get_lstring_default = \&aperl_duk_get_lstring_default;

=item C<get_magic>

see L<http://duktape.org/api.html#duk_get_magic>

=cut
*get_magic = \&aperl_duk_get_magic;

=item C<get_memory_functions>

see L<http://duktape.org/api.html#duk_get_memory_functions>

=cut
*get_memory_functions = \&aperl_duk_get_memory_functions;

=item C<get_now>

see L<http://duktape.org/api.html#duk_get_now>

=cut
*get_now = \&aperl_duk_get_now;

=item C<get_number>

see L<http://duktape.org/api.html#duk_get_number>

=cut
*get_number = \&aperl_duk_get_number;

=item C<get_number_default>

see L<http://duktape.org/api.html#duk_get_number_default>

=cut
*get_number_default = \&aperl_duk_get_number_default;

=item C<get_pointer>

see L<http://duktape.org/api.html#duk_get_pointer>

=cut
*get_pointer = \&aperl_duk_get_pointer;

=item C<get_pointer_default>

see L<http://duktape.org/api.html#duk_get_pointer_default>

=cut
*get_pointer_default = \&aperl_duk_get_pointer_default;

=item C<get_prop>

see L<http://duktape.org/api.html#duk_get_prop>

=cut
*get_prop = \&aperl_duk_get_prop;

=item C<get_prop_desc>

see L<http://duktape.org/api.html#duk_get_prop_desc>

=cut
*get_prop_desc = \&aperl_duk_get_prop_desc;

=item C<get_prop_heapptr>

see L<http://duktape.org/api.html#duk_get_prop_heapptr>

=cut
*get_prop_heapptr = \&aperl_duk_get_prop_heapptr;

=item C<get_prop_index>

see L<http://duktape.org/api.html#duk_get_prop_index>

=cut
*get_prop_index = \&aperl_duk_get_prop_index;

=item C<get_prop_lstring>

see L<http://duktape.org/api.html#duk_get_prop_lstring>

=cut
*get_prop_lstring = \&aperl_duk_get_prop_lstring;

=item C<get_prop_string>

see L<http://duktape.org/api.html#duk_get_prop_string>

=cut
*get_prop_string = \&aperl_duk_get_prop_string;

=item C<get_prototype>

see L<http://duktape.org/api.html#duk_get_prototype>

=cut
*get_prototype = \&aperl_duk_get_prototype;

=item C<get_string>

see L<http://duktape.org/api.html#duk_get_string>

=cut
*get_string = \&aperl_duk_get_string;

=item C<get_string_default>

see L<http://duktape.org/api.html#duk_get_string_default>

=cut
*get_string_default = \&aperl_duk_get_string_default;

=item C<get_top>

see L<http://duktape.org/api.html#duk_get_top>

=cut
*get_top = \&aperl_duk_get_top;

=item C<get_top_index>

see L<http://duktape.org/api.html#duk_get_top_index>

=cut
*get_top_index = \&aperl_duk_get_top_index;

=item C<get_type>

see L<http://duktape.org/api.html#duk_get_type>

=cut
*get_type = \&aperl_duk_get_type;

=item C<get_type_mask>

see L<http://duktape.org/api.html#duk_get_type_mask>

=cut
*get_type_mask = \&aperl_duk_get_type_mask;

=item C<get_uint>

see L<http://duktape.org/api.html#duk_get_uint>

=cut
*get_uint = \&aperl_duk_get_uint;

=item C<get_uint_default>

see L<http://duktape.org/api.html#duk_get_uint_default>

=cut
*get_uint_default = \&aperl_duk_get_uint_default;

=item C<has_prop>

see L<http://duktape.org/api.html#duk_has_prop>

=cut
*has_prop = \&aperl_duk_has_prop;

=item C<has_prop_heapptr>

see L<http://duktape.org/api.html#duk_has_prop_heapptr>

=cut
*has_prop_heapptr = \&aperl_duk_has_prop_heapptr;

=item C<has_prop_index>

see L<http://duktape.org/api.html#duk_has_prop_index>

=cut
*has_prop_index = \&aperl_duk_has_prop_index;

=item C<has_prop_lstring>

see L<http://duktape.org/api.html#duk_has_prop_lstring>

=cut
*has_prop_lstring = \&aperl_duk_has_prop_lstring;

=item C<has_prop_string>

see L<http://duktape.org/api.html#duk_has_prop_string>

=cut
*has_prop_string = \&aperl_duk_has_prop_string;

=item C<hex_decode>

see L<http://duktape.org/api.html#duk_hex_decode>

=cut
*hex_decode = \&aperl_duk_hex_decode;

=item C<hex_encode>

see L<http://duktape.org/api.html#duk_hex_encode>

=cut
*hex_encode = \&aperl_duk_hex_encode;

=item C<insert>

see L<http://duktape.org/api.html#duk_insert>

=cut
*insert = \&aperl_duk_insert;

=item C<inspect_callstack_entry>

see L<http://duktape.org/api.html#duk_inspect_callstack_entry>

=cut
*inspect_callstack_entry = \&aperl_duk_inspect_callstack_entry;

=item C<inspect_value>

see L<http://duktape.org/api.html#duk_inspect_value>

=cut
*inspect_value = \&aperl_duk_inspect_value;

=item C<instanceof>

see L<http://duktape.org/api.html#duk_instanceof>

=cut
*instanceof = \&aperl_duk_instanceof;

=item C<is_array>

see L<http://duktape.org/api.html#duk_is_array>

=cut
*is_array = \&aperl_duk_is_array;

=item C<is_boolean>

see L<http://duktape.org/api.html#duk_is_boolean>

=cut
*is_boolean = \&aperl_duk_is_boolean;

=item C<is_bound_function>

see L<http://duktape.org/api.html#duk_is_bound_function>

=cut
*is_bound_function = \&aperl_duk_is_bound_function;

=item C<is_buffer>

see L<http://duktape.org/api.html#duk_is_buffer>

=cut
*is_buffer = \&aperl_duk_is_buffer;

=item C<is_buffer_data>

see L<http://duktape.org/api.html#duk_is_buffer_data>

=cut
*is_buffer_data = \&aperl_duk_is_buffer_data;

=item C<is_c_function>

see L<http://duktape.org/api.html#duk_is_c_function>

=cut
*is_c_function = \&aperl_duk_is_c_function;

=item C<is_callable>

see L<http://duktape.org/api.html#duk_is_callable>

=cut
*is_callable = \&aperl_duk_is_callable;

=item C<is_constructable>

see L<http://duktape.org/api.html#duk_is_constructable>

=cut
*is_constructable = \&aperl_duk_is_constructable;

=item C<is_constructor_call>

see L<http://duktape.org/api.html#duk_is_constructor_call>

=cut
*is_constructor_call = \&aperl_duk_is_constructor_call;

=item C<is_dynamic_buffer>

see L<http://duktape.org/api.html#duk_is_dynamic_buffer>

=cut
*is_dynamic_buffer = \&aperl_duk_is_dynamic_buffer;

=item C<is_ecmascript_function>

see L<http://duktape.org/api.html#duk_is_ecmascript_function>

=cut
*is_ecmascript_function = \&aperl_duk_is_ecmascript_function;

=item C<is_error>

see L<http://duktape.org/api.html#duk_is_error>

=cut
*is_error = \&aperl_duk_is_error;

=item C<is_eval_error>

see L<http://duktape.org/api.html#duk_is_eval_error>

=cut
*is_eval_error = \&aperl_duk_is_eval_error;

=item C<is_fixed_buffer>

see L<http://duktape.org/api.html#duk_is_fixed_buffer>

=cut
*is_fixed_buffer = \&aperl_duk_is_fixed_buffer;

=item C<is_function>

see L<http://duktape.org/api.html#duk_is_function>

=cut
*is_function = \&aperl_duk_is_function;

=item C<is_lightfunc>

see L<http://duktape.org/api.html#duk_is_lightfunc>

=cut
*is_lightfunc = \&aperl_duk_is_lightfunc;

=item C<is_nan>

see L<http://duktape.org/api.html#duk_is_nan>

=cut
*is_nan = \&aperl_duk_is_nan;

=item C<is_null>

see L<http://duktape.org/api.html#duk_is_null>

=cut
*is_null = \&aperl_duk_is_null;

=item C<is_null_or_undefined>

see L<http://duktape.org/api.html#duk_is_null_or_undefined>

=cut
*is_null_or_undefined = \&aperl_duk_is_null_or_undefined;

=item C<is_number>

see L<http://duktape.org/api.html#duk_is_number>

=cut
*is_number = \&aperl_duk_is_number;

=item C<is_object>

see L<http://duktape.org/api.html#duk_is_object>

=cut
*is_object = \&aperl_duk_is_object;

=item C<is_object_coercible>

see L<http://duktape.org/api.html#duk_is_object_coercible>

=cut
*is_object_coercible = \&aperl_duk_is_object_coercible;

=item C<is_pointer>

see L<http://duktape.org/api.html#duk_is_pointer>

=cut
*is_pointer = \&aperl_duk_is_pointer;

=item C<is_primitive>

see L<http://duktape.org/api.html#duk_is_primitive>

=cut
*is_primitive = \&aperl_duk_is_primitive;

=item C<is_range_error>

see L<http://duktape.org/api.html#duk_is_range_error>

=cut
*is_range_error = \&aperl_duk_is_range_error;

=item C<is_reference_error>

see L<http://duktape.org/api.html#duk_is_reference_error>

=cut
*is_reference_error = \&aperl_duk_is_reference_error;

=item C<is_strict_call>

see L<http://duktape.org/api.html#duk_is_strict_call>

=cut
*is_strict_call = \&aperl_duk_is_strict_call;

=item C<is_string>

see L<http://duktape.org/api.html#duk_is_string>

=cut
*is_string = \&aperl_duk_is_string;

=item C<is_symbol>

see L<http://duktape.org/api.html#duk_is_symbol>

=cut
*is_symbol = \&aperl_duk_is_symbol;

=item C<is_syntax_error>

see L<http://duktape.org/api.html#duk_is_syntax_error>

=cut
*is_syntax_error = \&aperl_duk_is_syntax_error;

=item C<is_thread>

see L<http://duktape.org/api.html#duk_is_thread>

=cut
*is_thread = \&aperl_duk_is_thread;

=item C<is_type_error>

see L<http://duktape.org/api.html#duk_is_type_error>

=cut
*is_type_error = \&aperl_duk_is_type_error;

=item C<is_undefined>

see L<http://duktape.org/api.html#duk_is_undefined>

=cut
*is_undefined = \&aperl_duk_is_undefined;

=item C<is_uri_error>

see L<http://duktape.org/api.html#duk_is_uri_error>

=cut
*is_uri_error = \&aperl_duk_is_uri_error;

=item C<is_valid_index>

see L<http://duktape.org/api.html#duk_is_valid_index>

=cut
*is_valid_index = \&aperl_duk_is_valid_index;

=item C<join>

see L<http://duktape.org/api.html#duk_join>

=cut
*join = \&aperl_duk_join;

=item C<json_decode>

see L<http://duktape.org/api.html#duk_json_decode>

=cut
*json_decode = \&aperl_duk_json_decode;

=item C<json_encode>

see L<http://duktape.org/api.html#duk_json_encode>

=cut
*json_encode = \&aperl_duk_json_encode;

=item C<load_function>

see L<http://duktape.org/api.html#duk_load_function>

=cut
*load_function = \&aperl_duk_load_function;

=item C<map_string>

see L<http://duktape.org/api.html#duk_map_string>

=cut
*map_string = \&aperl_duk_map_string;

=item C<new>

see L<http://duktape.org/api.html#duk_new>

=cut
*new = \&aperl_duk_new;

=item C<next>

see L<http://duktape.org/api.html#duk_next>

=cut
*next = \&aperl_duk_next;

=item C<normalize_index>

see L<http://duktape.org/api.html#duk_normalize_index>

=cut
*normalize_index = \&aperl_duk_normalize_index;

=item C<opt_boolean>

see L<http://duktape.org/api.html#duk_opt_boolean>

=cut
*opt_boolean = \&aperl_duk_opt_boolean;

=item C<opt_buffer>

see L<http://duktape.org/api.html#duk_opt_buffer>

=cut
*opt_buffer = \&aperl_duk_opt_buffer;

=item C<opt_buffer_data>

see L<http://duktape.org/api.html#duk_opt_buffer_data>

=cut
*opt_buffer_data = \&aperl_duk_opt_buffer_data;

=item C<opt_c_function>

see L<http://duktape.org/api.html#duk_opt_c_function>

=cut
*opt_c_function = \&aperl_duk_opt_c_function;

=item C<opt_context>

see L<http://duktape.org/api.html#duk_opt_context>

=cut
*opt_context = \&aperl_duk_opt_context;

=item C<opt_heapptr>

see L<http://duktape.org/api.html#duk_opt_heapptr>

=cut
*opt_heapptr = \&aperl_duk_opt_heapptr;

=item C<opt_int>

see L<http://duktape.org/api.html#duk_opt_int>

=cut
*opt_int = \&aperl_duk_opt_int;

=item C<opt_lstring>

see L<http://duktape.org/api.html#duk_opt_lstring>

=cut
*opt_lstring = \&aperl_duk_opt_lstring;

=item C<opt_number>

see L<http://duktape.org/api.html#duk_opt_number>

=cut
*opt_number = \&aperl_duk_opt_number;

=item C<opt_pointer>

see L<http://duktape.org/api.html#duk_opt_pointer>

=cut
*opt_pointer = \&aperl_duk_opt_pointer;

=item C<opt_string>

see L<http://duktape.org/api.html#duk_opt_string>

=cut
*opt_string = \&aperl_duk_opt_string;

=item C<opt_uint>

see L<http://duktape.org/api.html#duk_opt_uint>

=cut
*opt_uint = \&aperl_duk_opt_uint;

=item C<pcall>

see L<http://duktape.org/api.html#duk_pcall>

=cut
*pcall = \&aperl_duk_pcall;

=item C<pcall_method>

see L<http://duktape.org/api.html#duk_pcall_method>

=cut
*pcall_method = \&aperl_duk_pcall_method;

=item C<pcall_prop>

see L<http://duktape.org/api.html#duk_pcall_prop>

=cut
*pcall_prop = \&aperl_duk_pcall_prop;

=item C<pcompile>

see L<http://duktape.org/api.html#duk_pcompile>

=cut
*pcompile = \&aperl_duk_pcompile;

=item C<pcompile_lstring>

see L<http://duktape.org/api.html#duk_pcompile_lstring>

=cut
*pcompile_lstring = \&aperl_duk_pcompile_lstring;

=item C<pcompile_lstring_filename>

see L<http://duktape.org/api.html#duk_pcompile_lstring_filename>

=cut
*pcompile_lstring_filename = \&aperl_duk_pcompile_lstring_filename;

=item C<pcompile_string>

see L<http://duktape.org/api.html#duk_pcompile_string>

=cut
*pcompile_string = \&aperl_duk_pcompile_string;

=item C<pcompile_string_filename>

see L<http://duktape.org/api.html#duk_pcompile_string_filename>

=cut
*pcompile_string_filename = \&aperl_duk_pcompile_string_filename;

=item C<peval>

see L<http://duktape.org/api.html#duk_peval>

=cut
*peval = \&aperl_duk_peval;

=item C<peval_lstring>

see L<http://duktape.org/api.html#duk_peval_lstring>

=cut
*peval_lstring = \&aperl_duk_peval_lstring;

=item C<peval_lstring_noresult>

see L<http://duktape.org/api.html#duk_peval_lstring_noresult>

=cut
*peval_lstring_noresult = \&aperl_duk_peval_lstring_noresult;

=item C<peval_noresult>

see L<http://duktape.org/api.html#duk_peval_noresult>

=cut
*peval_noresult = \&aperl_duk_peval_noresult;

=item C<peval_string>

see L<http://duktape.org/api.html#duk_peval_string>

=cut
*peval_string = \&aperl_duk_peval_string;

=item C<peval_string_noresult>

see L<http://duktape.org/api.html#duk_peval_string_noresult>

=cut
*peval_string_noresult = \&aperl_duk_peval_string_noresult;

=item C<pnew>

see L<http://duktape.org/api.html#duk_pnew>

=cut
*pnew = \&aperl_duk_pnew;

=item C<pop>

see L<http://duktape.org/api.html#duk_pop>

=cut
*pop = \&aperl_duk_pop;

=item C<pop_2>

see L<http://duktape.org/api.html#duk_pop_2>

=cut
*pop_2 = \&aperl_duk_pop_2;

=item C<pop_3>

see L<http://duktape.org/api.html#duk_pop_3>

=cut
*pop_3 = \&aperl_duk_pop_3;

=item C<pop_n>

see L<http://duktape.org/api.html#duk_pop_n>

=cut
*pop_n = \&aperl_duk_pop_n;

=item C<push_array>

see L<http://duktape.org/api.html#duk_push_array>

=cut
*push_array = \&aperl_duk_push_array;

=item C<push_bare_object>

see L<http://duktape.org/api.html#duk_push_bare_object>

=cut
*push_bare_object = \&aperl_duk_push_bare_object;

=item C<push_boolean>

see L<http://duktape.org/api.html#duk_push_boolean>

=cut
*push_boolean = \&aperl_duk_push_boolean;

=item C<push_buffer>

see L<http://duktape.org/api.html#duk_push_buffer>

=cut
*push_buffer = \&aperl_duk_push_buffer;

=item C<push_buffer_object>

see L<http://duktape.org/api.html#duk_push_buffer_object>

=cut
*push_buffer_object = \&aperl_duk_push_buffer_object;

=item C<push_c_function>

see L<http://duktape.org/api.html#duk_push_c_function>

=cut
*push_c_function = \&aperl_duk_push_c_function;

=item C<push_c_lightfunc>

see L<http://duktape.org/api.html#duk_push_c_lightfunc>

=cut
*push_c_lightfunc = \&aperl_duk_push_c_lightfunc;

=item C<push_context_dump>

see L<http://duktape.org/api.html#duk_push_context_dump>

=cut
*push_context_dump = \&aperl_duk_push_context_dump;

=item C<push_current_function>

see L<http://duktape.org/api.html#duk_push_current_function>

=cut
*push_current_function = \&aperl_duk_push_current_function;

=item C<push_current_thread>

see L<http://duktape.org/api.html#duk_push_current_thread>

=cut
*push_current_thread = \&aperl_duk_push_current_thread;

=item C<push_dynamic_buffer>

see L<http://duktape.org/api.html#duk_push_dynamic_buffer>

=cut
*push_dynamic_buffer = \&aperl_duk_push_dynamic_buffer;

=item C<push_error_object_va>

see L<http://duktape.org/api.html#duk_push_error_object_va>

=cut
*push_error_object_va = \&aperl_duk_push_error_object_va;

=item C<push_external_buffer>

see L<http://duktape.org/api.html#duk_push_external_buffer>

=cut
*push_external_buffer = \&aperl_duk_push_external_buffer;

=item C<push_false>

see L<http://duktape.org/api.html#duk_push_false>

=cut
*push_false = \&aperl_duk_push_false;

=item C<push_fixed_buffer>

see L<http://duktape.org/api.html#duk_push_fixed_buffer>

=cut
*push_fixed_buffer = \&aperl_duk_push_fixed_buffer;

=item C<push_global_object>

see L<http://duktape.org/api.html#duk_push_global_object>

=cut
*push_global_object = \&aperl_duk_push_global_object;

=item C<push_global_stash>

see L<http://duktape.org/api.html#duk_push_global_stash>

=cut
*push_global_stash = \&aperl_duk_push_global_stash;

=item C<push_heap_stash>

see L<http://duktape.org/api.html#duk_push_heap_stash>

=cut
*push_heap_stash = \&aperl_duk_push_heap_stash;

=item C<push_heapptr>

see L<http://duktape.org/api.html#duk_push_heapptr>

=cut
*push_heapptr = \&aperl_duk_push_heapptr;

=item C<push_int>

see L<http://duktape.org/api.html#duk_push_int>

=cut
*push_int = \&aperl_duk_push_int;

=item C<push_lstring>

see L<http://duktape.org/api.html#duk_push_lstring>

=cut
*push_lstring = \&aperl_duk_push_lstring;

=item C<push_nan>

see L<http://duktape.org/api.html#duk_push_nan>

=cut
*push_nan = \&aperl_duk_push_nan;

=item C<push_null>

see L<http://duktape.org/api.html#duk_push_null>

=cut
*push_null = \&aperl_duk_push_null;

=item C<push_number>

see L<http://duktape.org/api.html#duk_push_number>

=cut
*push_number = \&aperl_duk_push_number;

=item C<push_object>

see L<http://duktape.org/api.html#duk_push_object>

=cut
*push_object = \&aperl_duk_push_object;

=item C<push_pointer>

see L<http://duktape.org/api.html#duk_push_pointer>

=cut
*push_pointer = \&aperl_duk_push_pointer;

=item C<push_proxy>

see L<http://duktape.org/api.html#duk_push_proxy>

=cut
*push_proxy = \&aperl_duk_push_proxy;

=item C<push_string>

see L<http://duktape.org/api.html#duk_push_string>

=cut
*push_string = \&aperl_duk_push_string;

=item C<push_this>

see L<http://duktape.org/api.html#duk_push_this>

=cut
*push_this = \&aperl_duk_push_this;

=item C<push_thread>

see L<http://duktape.org/api.html#duk_push_thread>

=cut
*push_thread = \&aperl_duk_push_thread;

=item C<push_thread_new_globalenv>

see L<http://duktape.org/api.html#duk_push_thread_new_globalenv>

=cut
*push_thread_new_globalenv = \&aperl_duk_push_thread_new_globalenv;

=item C<push_thread_stash>

see L<http://duktape.org/api.html#duk_push_thread_stash>

=cut
*push_thread_stash = \&aperl_duk_push_thread_stash;

=item C<push_true>

see L<http://duktape.org/api.html#duk_push_true>

=cut
*push_true = \&aperl_duk_push_true;

=item C<push_uint>

see L<http://duktape.org/api.html#duk_push_uint>

=cut
*push_uint = \&aperl_duk_push_uint;

=item C<push_undefined>

see L<http://duktape.org/api.html#duk_push_undefined>

=cut
*push_undefined = \&aperl_duk_push_undefined;

=item C<push_vsprintf>

see L<http://duktape.org/api.html#duk_push_vsprintf>

=cut
*push_vsprintf = \&aperl_duk_push_vsprintf;

=item C<put_function_list>

see L<http://duktape.org/api.html#duk_put_function_list>

=cut
*put_function_list = \&aperl_duk_put_function_list;

=item C<put_global_lstring>

see L<http://duktape.org/api.html#duk_put_global_lstring>

=cut
*put_global_lstring = \&aperl_duk_put_global_lstring;

=item C<put_global_string>

see L<http://duktape.org/api.html#duk_put_global_string>

=cut
*put_global_string = \&aperl_duk_put_global_string;

=item C<put_number_list>

see L<http://duktape.org/api.html#duk_put_number_list>

=cut
*put_number_list = \&aperl_duk_put_number_list;

=item C<put_prop>

see L<http://duktape.org/api.html#duk_put_prop>

=cut
*put_prop = \&aperl_duk_put_prop;

=item C<put_prop_heapptr>

see L<http://duktape.org/api.html#duk_put_prop_heapptr>

=cut
*put_prop_heapptr = \&aperl_duk_put_prop_heapptr;

=item C<put_prop_index>

see L<http://duktape.org/api.html#duk_put_prop_index>

=cut
*put_prop_index = \&aperl_duk_put_prop_index;

=item C<put_prop_lstring>

see L<http://duktape.org/api.html#duk_put_prop_lstring>

=cut
*put_prop_lstring = \&aperl_duk_put_prop_lstring;

=item C<put_prop_string>

see L<http://duktape.org/api.html#duk_put_prop_string>

=cut
*put_prop_string = \&aperl_duk_put_prop_string;

=item C<range_error_va>

see L<http://duktape.org/api.html#duk_range_error_va>

=cut
*range_error_va = \&aperl_duk_range_error_va;

=item C<realloc>

see L<http://duktape.org/api.html#duk_realloc>

=cut
*realloc = \&aperl_duk_realloc;

=item C<realloc_raw>

see L<http://duktape.org/api.html#duk_realloc_raw>

=cut
*realloc_raw = \&aperl_duk_realloc_raw;

=item C<reference_error_va>

see L<http://duktape.org/api.html#duk_reference_error_va>

=cut
*reference_error_va = \&aperl_duk_reference_error_va;

=item C<remove>

see L<http://duktape.org/api.html#duk_remove>

=cut
*remove = \&aperl_duk_remove;

=item C<replace>

see L<http://duktape.org/api.html#duk_replace>

=cut
*replace = \&aperl_duk_replace;

=item C<require_boolean>

see L<http://duktape.org/api.html#duk_require_boolean>

=cut
*require_boolean = \&aperl_duk_require_boolean;

=item C<require_buffer>

see L<http://duktape.org/api.html#duk_require_buffer>

=cut
*require_buffer = \&aperl_duk_require_buffer;

=item C<require_buffer_data>

see L<http://duktape.org/api.html#duk_require_buffer_data>

=cut
*require_buffer_data = \&aperl_duk_require_buffer_data;

=item C<require_c_function>

see L<http://duktape.org/api.html#duk_require_c_function>

=cut
*require_c_function = \&aperl_duk_require_c_function;

=item C<require_callable>

see L<http://duktape.org/api.html#duk_require_callable>

=cut
*require_callable = \&aperl_duk_require_callable;

=item C<require_context>

see L<http://duktape.org/api.html#duk_require_context>

=cut
*require_context = \&aperl_duk_require_context;

=item C<require_function>

see L<http://duktape.org/api.html#duk_require_function>

=cut
*require_function = \&aperl_duk_require_function;

=item C<require_heapptr>

see L<http://duktape.org/api.html#duk_require_heapptr>

=cut
*require_heapptr = \&aperl_duk_require_heapptr;

=item C<require_int>

see L<http://duktape.org/api.html#duk_require_int>

=cut
*require_int = \&aperl_duk_require_int;

=item C<require_lstring>

see L<http://duktape.org/api.html#duk_require_lstring>

=cut
*require_lstring = \&aperl_duk_require_lstring;

=item C<require_normalize_index>

see L<http://duktape.org/api.html#duk_require_normalize_index>

=cut
*require_normalize_index = \&aperl_duk_require_normalize_index;

=item C<require_null>

see L<http://duktape.org/api.html#duk_require_null>

=cut
*require_null = \&aperl_duk_require_null;

=item C<require_number>

see L<http://duktape.org/api.html#duk_require_number>

=cut
*require_number = \&aperl_duk_require_number;

=item C<require_object>

see L<http://duktape.org/api.html#duk_require_object>

=cut
*require_object = \&aperl_duk_require_object;

=item C<require_object_coercible>

see L<http://duktape.org/api.html#duk_require_object_coercible>

=cut
*require_object_coercible = \&aperl_duk_require_object_coercible;

=item C<require_pointer>

see L<http://duktape.org/api.html#duk_require_pointer>

=cut
*require_pointer = \&aperl_duk_require_pointer;

=item C<require_stack>

see L<http://duktape.org/api.html#duk_require_stack>

=cut
*require_stack = \&aperl_duk_require_stack;

=item C<require_stack_top>

see L<http://duktape.org/api.html#duk_require_stack_top>

=cut
*require_stack_top = \&aperl_duk_require_stack_top;

=item C<require_string>

see L<http://duktape.org/api.html#duk_require_string>

=cut
*require_string = \&aperl_duk_require_string;

=item C<require_top_index>

see L<http://duktape.org/api.html#duk_require_top_index>

=cut
*require_top_index = \&aperl_duk_require_top_index;

=item C<require_type_mask>

see L<http://duktape.org/api.html#duk_require_type_mask>

=cut
*require_type_mask = \&aperl_duk_require_type_mask;

=item C<require_uint>

see L<http://duktape.org/api.html#duk_require_uint>

=cut
*require_uint = \&aperl_duk_require_uint;

=item C<require_undefined>

see L<http://duktape.org/api.html#duk_require_undefined>

=cut
*require_undefined = \&aperl_duk_require_undefined;

=item C<require_valid_index>

see L<http://duktape.org/api.html#duk_require_valid_index>

=cut
*require_valid_index = \&aperl_duk_require_valid_index;

=item C<resize_buffer>

see L<http://duktape.org/api.html#duk_resize_buffer>

=cut
*resize_buffer = \&aperl_duk_resize_buffer;

=item C<resume>

see L<http://duktape.org/api.html#duk_resume>

=cut
*resume = \&aperl_duk_resume;

=item C<safe_call>

see L<http://duktape.org/api.html#duk_safe_call>

=cut
*safe_call = \&aperl_duk_safe_call;

=item C<safe_to_lstring>

see L<http://duktape.org/api.html#duk_safe_to_lstring>

=cut
*safe_to_lstring = \&aperl_duk_safe_to_lstring;

=item C<safe_to_string>

see L<http://duktape.org/api.html#duk_safe_to_string>

=cut
*safe_to_string = \&aperl_duk_safe_to_string;

=item C<samevalue>

see L<http://duktape.org/api.html#duk_samevalue>

=cut
*samevalue = \&aperl_duk_samevalue;

=item C<seal>

see L<http://duktape.org/api.html#duk_seal>

=cut
*seal = \&aperl_duk_seal;

=item C<set_finalizer>

see L<http://duktape.org/api.html#duk_set_finalizer>

=cut
*set_finalizer = \&aperl_duk_set_finalizer;

=item C<set_global_object>

see L<http://duktape.org/api.html#duk_set_global_object>

=cut
*set_global_object = \&aperl_duk_set_global_object;

=item C<set_length>

see L<http://duktape.org/api.html#duk_set_length>

=cut
*set_length = \&aperl_duk_set_length;

=item C<set_magic>

see L<http://duktape.org/api.html#duk_set_magic>

=cut
*set_magic = \&aperl_duk_set_magic;

=item C<set_prototype>

see L<http://duktape.org/api.html#duk_set_prototype>

=cut
*set_prototype = \&aperl_duk_set_prototype;

=item C<set_top>

see L<http://duktape.org/api.html#duk_set_top>

=cut
*set_top = \&aperl_duk_set_top;

=item C<steal_buffer>

see L<http://duktape.org/api.html#duk_steal_buffer>

=cut
*steal_buffer = \&aperl_duk_steal_buffer;

=item C<strict_equals>

see L<http://duktape.org/api.html#duk_strict_equals>

=cut
*strict_equals = \&aperl_duk_strict_equals;

=item C<substring>

see L<http://duktape.org/api.html#duk_substring>

=cut
*substring = \&aperl_duk_substring;

=item C<suspend>

see L<http://duktape.org/api.html#duk_suspend>

=cut
*suspend = \&aperl_duk_suspend;

=item C<swap>

see L<http://duktape.org/api.html#duk_swap>

=cut
*swap = \&aperl_duk_swap;

=item C<swap_top>

see L<http://duktape.org/api.html#duk_swap_top>

=cut
*swap_top = \&aperl_duk_swap_top;

=item C<syntax_error_va>

see L<http://duktape.org/api.html#duk_syntax_error_va>

=cut
*syntax_error_va = \&aperl_duk_syntax_error_va;

=item C<throw>

see L<http://duktape.org/api.html#duk_throw>

=cut
*throw = \&aperl_duk_throw;

=item C<time_to_components>

see L<http://duktape.org/api.html#duk_time_to_components>

=cut
*time_to_components = \&aperl_duk_time_to_components;

=item C<to_boolean>

see L<http://duktape.org/api.html#duk_to_boolean>

=cut
*to_boolean = \&aperl_duk_to_boolean;

=item C<to_buffer>

see L<http://duktape.org/api.html#duk_to_buffer>

=cut
*to_buffer = \&aperl_duk_to_buffer;

=item C<to_dynamic_buffer>

see L<http://duktape.org/api.html#duk_to_dynamic_buffer>

=cut
*to_dynamic_buffer = \&aperl_duk_to_dynamic_buffer;

=item C<to_fixed_buffer>

see L<http://duktape.org/api.html#duk_to_fixed_buffer>

=cut
*to_fixed_buffer = \&aperl_duk_to_fixed_buffer;

=item C<to_int>

see L<http://duktape.org/api.html#duk_to_int>

=cut
*to_int = \&aperl_duk_to_int;

=item C<to_int32>

see L<http://duktape.org/api.html#duk_to_int32>

=cut
*to_int32 = \&aperl_duk_to_int32;

=item C<to_lstring>

see L<http://duktape.org/api.html#duk_to_lstring>

=cut
*to_lstring = \&aperl_duk_to_lstring;

=item C<to_null>

see L<http://duktape.org/api.html#duk_to_null>

=cut
*to_null = \&aperl_duk_to_null;

=item C<to_number>

see L<http://duktape.org/api.html#duk_to_number>

=cut
*to_number = \&aperl_duk_to_number;

=item C<to_object>

see L<http://duktape.org/api.html#duk_to_object>

=cut
*to_object = \&aperl_duk_to_object;

=item C<to_pointer>

see L<http://duktape.org/api.html#duk_to_pointer>

=cut
*to_pointer = \&aperl_duk_to_pointer;

=item C<to_primitive>

see L<http://duktape.org/api.html#duk_to_primitive>

=cut
*to_primitive = \&aperl_duk_to_primitive;

=item C<to_string>

see L<http://duktape.org/api.html#duk_to_string>

=cut
*to_string = \&aperl_duk_to_string;

=item C<to_uint>

see L<http://duktape.org/api.html#duk_to_uint>

=cut
*to_uint = \&aperl_duk_to_uint;

=item C<to_uint16>

see L<http://duktape.org/api.html#duk_to_uint16>

=cut
*to_uint16 = \&aperl_duk_to_uint16;

=item C<to_uint32>

see L<http://duktape.org/api.html#duk_to_uint32>

=cut
*to_uint32 = \&aperl_duk_to_uint32;

=item C<to_undefined>

see L<http://duktape.org/api.html#duk_to_undefined>

=cut
*to_undefined = \&aperl_duk_to_undefined;

=item C<trim>

see L<http://duktape.org/api.html#duk_trim>

=cut
*trim = \&aperl_duk_trim;

=item C<type_error_va>

see L<http://duktape.org/api.html#duk_type_error_va>

=cut
*type_error_va = \&aperl_duk_type_error_va;

=item C<uri_error_va>

see L<http://duktape.org/api.html#duk_uri_error_va>

=cut
*uri_error_va = \&aperl_duk_uri_error_va;


=back

=cut
1;
