dop251/goja

Features

• ECMAScript Compliant Engines - Functions as a specification-compliant engine for parsing and executing JavaScript code according to ECMAScript standards.
• Go-Based Language Runtimes - Provides a JavaScript runtime implemented entirely in Go without relying on C bindings or external libraries.
• Custom Scripting Engines - Provides a complete ECMAScript runtime for executing custom logic within Go applications.
• Native Type Mappings - Exposes internal Go structs and arrays as JavaScript objects via reflection.
• JavaScript Engine Embedding - Integrates a full JavaScript execution engine as an embedded component within Go applications.
• Cross-Language Data Exchange - Passes native values into the script runtime and exports script objects back into native types.
• Cross-Language Data Mapping - Transforms complex data structures between Go types and JavaScript objects for bidirectional communication.
• Cross-Language Value Mappings - Translates data types between the Go host and JavaScript runtime while handling circular references.
• Embedded Scripting Engines - Provides a programmable scripting layer integrated directly into Go binaries for dynamic logic.
• Foreign Function Bindings - Exposes functions from Go to JavaScript and converts foreign function types into callable local types.
• Function Execution Models - Executes standard, async, and generator functions while supporting functional patterns like binding, calling, and applying.
• Host Function Exposure - Converts JavaScript functions into callable Go functions to facilitate bidirectional communication.
• JavaScript Engines - A full JavaScript runtime implemented entirely in Go.
• JavaScript Interop - Facilitates the exchange of data and function calls between Go and JavaScript using shared objects and maps.
• Language Runtime Bridges - Provides a mechanism for bidirectional data exchange and function invocation between Go and JavaScript.
• Native-to-Script Function Invocations - Allows native Go code to invoke functions defined within the JavaScript environment.
• Prototype-Based Inheritance - Implements object inheritance and property lookup through a chain of prototype objects.
• Pure Go Portings - Implements a JavaScript runtime entirely in Go, eliminating the need for Cgo or native dependencies.
• JavaScript Runtimes - Provides a high-performance embedded environment to execute JavaScript and TypeScript code within a Go host.
• Abstract Syntax Tree Parsing - Converts JavaScript source code into a structured tree of nodes for program analysis and execution.
• Asynchronous Execution - Manages asynchronous execution flows using a promise-based model to resolve and reject deferred values.
• Script Value Exports - Converts JavaScript objects and arrays, including circular references, into native Go types.
• Host Object Binding - Maps native Go structs and slices to JavaScript objects using reflection to translate field names and methods.
• Language Map Collections - Implements the native JavaScript Map object for flexible key-value storage and iteration.
• Property Name Mappings - Translates Go field and method names into JavaScript property names while managing visibility.
• Struct Field Mappings - Maps native Go struct fields and methods to JavaScript naming conventions.
• Typed Arrays - Handles fixed-length binary data buffers and views using standardized integer array types.
• Host Object Binding - Connects custom host-language objects and arrays to the script environment to manage properties.
• Script-to-Native Type Mappings - Converts native Go map structures into JavaScript objects for standard property access and iteration.
• CPU Profilers - Collects CPU usage and call stack samples to identify performance bottlenecks in script execution.
• Dynamic Configuration - Enables the use of JavaScript as a flexible configuration language that can be updated at runtime.
• Boolean Logic Types - Implements native boolean primitive types and prototype methods to evaluate truthy and falsy values.
• Date and Time Runtimes - Manipulates date and time by parsing ISO strings and managing timestamps within the execution environment.
• Object Property Descriptors - Manages object property descriptors to control value visibility and prototype retrieval.
• Native Array Transformations - Converts native Go slices into JavaScript arrays, maintaining synchronization for reading and modification.
• Numeric Operation Runtimes - Performs number manipulations including type conversion, precision formatting, and finiteness checks.
• Custom Array Interfacing - Connects arrays with external data handlers to manage indexed element access and length modifications.
• Proxy Objects - Implements proxy objects that wrap target objects to intercept and redefine operations like property access.
• Reflection APIs - Provides a standardized Reflect API for performing runtime meta-operations on objects.
• Regular Expression Engines - Implements a regular expression engine that transforms and validates patterns according to ECMAScript standards.
• Set Operations - Implements standard JavaScript Set objects for managing unique value collections.
• Lexical Analyzers - Transforms raw JavaScript character streams into structured tokens based on ECMAScript rules.
• Unique Symbol Management - Manages unique symbol values and a global registry to ensure distinct identity for object properties.
• Runtime Integer Implementations - Processes arbitrary precision integers to support numeric operations exceeding standard double-precision limits.
• Async Flow Patterns - Implements asynchronous flow patterns by managing promise resolution and rejection to trigger deferred reactions.
• String Manipulation - Provides native JavaScript string operations including concatenation, substringing, and case conversion.
• UTF-16 String Implementations - Supports native string construction that handles complex character encodings and invalid UTF-16 surrogate pairs.
• Compilers and Interpreters - ECMAScript 5.1+ implementation.
• Language Runtimes - ECMAScript 5.1 implementation written in Go.
• Scripting Languages - ECMAScript 5.1+ implementation in Go.

Historial de estrellas