private static WrapperException WrapJsException(OriginalException originalException)
        {
            WrapperException wrapperException;
            string           message      = originalException.Message;
            string           description  = message;
            string           type         = originalException.Type;
            string           documentName = originalException.Resource;
            int lineNumber   = originalException.Line;
            int columnNumber = originalException.Column;

            if (originalException is OriginalInteropException)
            {
                wrapperException = new WrapperException(message, EngineName, EngineVersion, originalException);
            }
            else if (type == null && message.Equals(":  at line: 0 column: 1.", StringComparison.Ordinal))
            {
                wrapperException = new WrapperInterruptedException(CoreStrings.Runtime_ScriptInterrupted,
                                                                   EngineName, EngineVersion, originalException);
            }
            else
            {
                Match scriptErrorMessageMatch = _scriptErrorMessageRegex.Match(message);
                if (scriptErrorMessageMatch.Success)
                {
                    WrapperScriptException wrapperScriptException;
                    description = scriptErrorMessageMatch.Groups["description"].Value;
                    message     = JsErrorHelpers.GenerateScriptErrorMessage(type, description, documentName,
                                                                            lineNumber, columnNumber);

                    if (type == JsErrorType.Syntax)
                    {
                        wrapperScriptException = new WrapperCompilationException(message,
                                                                                 EngineName, EngineVersion, originalException);
                    }
                    else
                    {
                        wrapperScriptException = new WrapperRuntimeException(message,
                                                                             EngineName, EngineVersion, originalException);
                    }
                    wrapperScriptException.Type         = type;
                    wrapperScriptException.DocumentName = documentName;
                    wrapperScriptException.LineNumber   = lineNumber;
                    wrapperScriptException.ColumnNumber = columnNumber;

                    wrapperException = wrapperScriptException;
                }
                else
                {
                    wrapperException = new WrapperException(message, EngineName, EngineVersion,
                                                            originalException);
                }
            }

            wrapperException.Description = description;

            return(wrapperException);
        }
        private static WrapperException WrapJavaScriptException(
            OriginalJavaScriptException originalJavaScriptException)
        {
            WrapperException wrapperException;
            string           message = originalJavaScriptException.Message;

            if (string.IsNullOrWhiteSpace(message))
            {
                message = "An unknown error occurred";
            }
            string description  = message;
            string type         = string.Empty;
            string documentName = originalJavaScriptException.Location.Source;
            int    lineNumber   = originalJavaScriptException.LineNumber;
            int    columnNumber = originalJavaScriptException.Column + 1;

            OriginalValue errorValue = originalJavaScriptException.Error;

            if (errorValue.IsObject())
            {
                OriginalObjectInstance errorObject = errorValue.AsObject();

                OriginalValue namePropertyValue = errorObject.Get("name");
                if (namePropertyValue.IsString())
                {
                    type = namePropertyValue.AsString();
                }
            }

            if (!string.IsNullOrEmpty(type))
            {
                message = JsErrorHelpers.GenerateScriptErrorMessage(type, description, documentName, lineNumber,
                                                                    columnNumber);

                var wrapperRuntimeException = new WrapperRuntimeException(message, EngineName, EngineVersion,
                                                                          originalJavaScriptException)
                {
                    Type         = type,
                    DocumentName = documentName,
                    LineNumber   = lineNumber,
                    ColumnNumber = columnNumber
                };

                wrapperException = wrapperRuntimeException;
            }
            else
            {
                wrapperException = new WrapperException(message, EngineName, EngineVersion,
                                                        originalJavaScriptException);
            }

            wrapperException.Description = description;

            return(wrapperException);
        }
예제 #3
0
        private static WrapperEngineLoadException WrapTypeLoadException(
            TypeLoadException originalTypeLoadException)
        {
            string originalMessage = originalTypeLoadException.Message;
            string description;
            string message;

            Match errorMessageMatch = _interfaceAssemblyLoadErrorMessage.Match(originalMessage);

            if (errorMessageMatch.Success)
            {
                string assemblyFileName = errorMessageMatch.Groups["assemblyFileName"].Value;

                var           stringBuilderPool  = StringBuilderPool.Shared;
                StringBuilder descriptionBuilder = stringBuilderPool.Rent();
                descriptionBuilder.AppendFormat(CoreStrings.Engine_AssemblyNotFound, assemblyFileName);
                descriptionBuilder.Append(" ");
                if (assemblyFileName == DllName.V8LibCpp64Bit || assemblyFileName == DllName.V8LibCpp32Bit)
                {
                    descriptionBuilder.AppendFormat(CoreStrings.Engine_NuGetPackageInstallationRequired,
                                                    assemblyFileName == DllName.V8LibCpp64Bit ?
                                                    "JavaScriptEngineSwitcher.V8.Native.win-x64"
                                                        :
                                                    "JavaScriptEngineSwitcher.V8.Native.win-x86"
                                                    );
                    descriptionBuilder.Append(" ");
                    descriptionBuilder.Append(Strings.Engine_VcRedist2017InstallationRequired);
                }
                else
                {
                    descriptionBuilder.AppendFormat(CoreStrings.Common_SeeOriginalErrorMessage, originalMessage);
                }

                description = descriptionBuilder.ToString();
                stringBuilderPool.Return(descriptionBuilder);

                message = JsErrorHelpers.GenerateEngineLoadErrorMessage(description, EngineName);
            }
            else
            {
                description = originalMessage;
                message     = JsErrorHelpers.GenerateEngineLoadErrorMessage(description, EngineName, true);
            }

            var wrapperEngineLoadException = new WrapperEngineLoadException(message, EngineName, EngineVersion,
                                                                            originalTypeLoadException)
            {
                Description = description
            };

            return(wrapperEngineLoadException);
        }
예제 #4
0
        /// <summary>
        /// Constructs an instance of adapter for the V8 JS engine (Microsoft ClearScript.V8)
        /// </summary>
        /// <param name="settings">Settings of the V8 JS engine</param>
        public V8JsEngine(V8Settings settings)
        {
            V8Settings v8Settings = settings ?? new V8Settings();

            var constraints = new OriginalRuntimeConstraints
            {
                HeapExpansionMultiplier  = v8Settings.HeapExpansionMultiplier,
                MaxArrayBufferAllocation = v8Settings.MaxArrayBufferAllocation,
                MaxNewSpaceSize          = v8Settings.MaxNewSpaceSize,
                MaxOldSpaceSize          = v8Settings.MaxOldSpaceSize
            };

            OriginalEngineFlags flags = OriginalEngineFlags.None;

            if (v8Settings.AwaitDebuggerAndPauseOnStart)
            {
                flags |= OriginalEngineFlags.AwaitDebuggerAndPauseOnStart;
            }
            if (v8Settings.EnableDebugging)
            {
                flags |= OriginalEngineFlags.EnableDebugging;
            }
            if (v8Settings.EnableRemoteDebugging)
            {
                flags |= OriginalEngineFlags.EnableRemoteDebugging;
            }
            if (v8Settings.DisableGlobalMembers)
            {
                flags |= OriginalEngineFlags.DisableGlobalMembers;
            }

            int debugPort = v8Settings.DebugPort;

            try
            {
                _jsEngine = new OriginalEngine(constraints, flags, debugPort)
                {
                    MaxRuntimeHeapSize            = v8Settings.MaxHeapSize,
                    RuntimeHeapSizeSampleInterval = v8Settings.HeapSizeSampleInterval,
                    MaxRuntimeStackUsage          = v8Settings.MaxStackUsage
                };
            }
            catch (TypeLoadException e)
            {
                throw WrapTypeLoadException(e);
            }
            catch (Exception e)
            {
                throw JsErrorHelpers.WrapEngineLoadException(e, EngineName, EngineVersion, true);
            }
        }
        /// <summary>
        /// "Cleans" CSS code by using Clean-css
        /// </summary>
        /// <param name="content">Text content of CSS asset</param>
        /// <param name="path">Path to CSS file</param>
        /// <returns>Minified text content of CSS asset</returns>
        public string Clean(string content, string path)
        {
            Initialize();

            string newContent;

            try
            {
                var result = _jsEngine.Evaluate <string>(
                    string.Format(CLEANING_FUNCTION_CALL_TEMPLATE,
                                  JsonConvert.SerializeObject(content), _optionsString));

                var json = JObject.Parse(result);

                var errors = json["errors"] != null ? json["errors"] as JArray : null;
                if (errors != null && errors.Count > 0)
                {
                    throw new CssCleaningException(FormatErrorDetails(errors[0].Value <string>(), true,
                                                                      path));
                }

                if (_options.Severity > 0)
                {
                    var warnings = json["warnings"] != null ? json["warnings"] as JArray : null;
                    if (warnings != null && warnings.Count > 0)
                    {
                        throw new CssCleaningException(FormatErrorDetails(warnings[0].Value <string>(),
                                                                          false, path));
                    }
                }

                newContent = json.Value <string>("minifiedCode");
            }
            catch (JsScriptException e)
            {
                string errorDetails = JsErrorHelpers.GenerateErrorDetails(e, true);

                var           stringBuilderPool   = StringBuilderPool.Shared;
                StringBuilder errorMessageBuilder = stringBuilderPool.Rent();
                errorMessageBuilder.AppendLine(e.Message);
                errorMessageBuilder.AppendLine();
                errorMessageBuilder.Append(errorDetails);

                string errorMessage = errorMessageBuilder.ToString();
                stringBuilderPool.Return(errorMessageBuilder);

                throw new CssCleaningException(errorMessage);
            }

            return(newContent);
        }
예제 #6
0
        /// <summary>
        /// Constructs an instance of adapter for the Jint JS engine
        /// </summary>
        /// <param name="settings">Settings of the Jint JS engine</param>
        public JintJsEngine(JintSettings settings)
        {
            _cancellationTokenSource = new CancellationTokenSource();
            _cancellationConstraint  = new OriginalCancellationConstraint(_cancellationTokenSource.Token);

            JintSettings jintSettings = settings ?? new JintSettings();

            _debuggerBreakCallback = jintSettings.DebuggerBreakCallback;
            _debuggerStepCallback  = jintSettings.DebuggerStepCallback;
            var debuggerStatementHandlingMode = Utils.GetEnumFromOtherEnum <JsDebuggerStatementHandlingMode, OriginalDebuggerStatementHandlingMode>(
                jintSettings.DebuggerStatementHandlingMode);

            try
            {
                _jsEngine = new OriginalEngine(options => {
                    options
                    .WithoutConstraint(c => c is OriginalCancellationConstraint)
                    .Constraint(_cancellationConstraint)
                    .DebuggerStatementHandling(debuggerStatementHandlingMode)
                    .DebugMode(jintSettings.EnableDebugging)
                    .LimitMemory(jintSettings.MemoryLimit)
                    .LimitRecursion(jintSettings.MaxRecursionDepth)
                    .LocalTimeZone(jintSettings.LocalTimeZone ?? TimeZoneInfo.Local)
                    .MaxArraySize(jintSettings.MaxArraySize)
                    .MaxStatements(jintSettings.MaxStatements)
                    .Strict(jintSettings.StrictMode)
                    .TimeoutInterval(jintSettings.TimeoutInterval)
                    ;

                    if (jintSettings.RegexTimeoutInterval.HasValue)
                    {
                        options.RegexTimeoutInterval(jintSettings.RegexTimeoutInterval.Value);
                    }

                    options.AddObjectConverter(new UndefinedConverter());
                });
                if (_debuggerBreakCallback != null)
                {
                    _jsEngine.DebugHandler.Break += _debuggerBreakCallback;
                }
                if (_debuggerStepCallback != null)
                {
                    _jsEngine.DebugHandler.Step += _debuggerStepCallback;
                }
            }
            catch (Exception e)
            {
                throw JsErrorHelpers.WrapEngineLoadException(e, EngineName, EngineVersion, true);
            }
        }
예제 #7
0
        private JsValue EvaluateModuleInternal(string code, string path, out JsValue moduleNamespace)
        {
            JsModuleRecord invalidModule  = JsModuleRecord.Invalid;
            string         modulePath     = path;
            string         moduleFullPath = GetModuleFullPath(invalidModule, modulePath);

            JsValue result;

            lock (_evaluationSynchronizer)
            {
                JsModuleRecord module = JsModuleRecord.Create(invalidModule, modulePath, moduleFullPath);
                module.SetFetchImportedModuleCallback(_fetchImportedModuleCallback);
                module.SetNotifyModuleReadyCallback(_notifyModuleReadyCallback);

                ModuleJob job = new ModuleJob
                {
                    Module    = module,
                    Script    = code,
                    SourceUrl = moduleFullPath,
                    IsParsed  = false
                };
                _moduleJobQueue.Enqueue(job);

                try
                {
                    result = EvaluateModulesTree(out moduleNamespace);
                    JsValue exception = module.Exception;

                    if (exception.IsValid)
                    {
                        JsValue metadata = JsValue.Invalid;
                        if (!JsContext.HasException)
                        {
                            JsErrorHelpers.SetException(exception);
                        }
                        metadata = JsContext.GetAndClearExceptionWithMetadata();

                        throw JsErrorHelpers.CreateScriptExceptionFromMetadata(metadata);
                    }
                }
                finally
                {
                    _moduleJobQueue.Clear();
                    module.Release();
                }
            }

            return(result);
        }
        private static WrapperRuntimeException WrapMemoryLimitExceededException(
            OriginalMemoryLimitExceededException originalMemoryException)
        {
            string description = originalMemoryException.Message;
            string type        = JsErrorType.Common;
            string message     = JsErrorHelpers.GenerateScriptErrorMessage(type, description, string.Empty);

            var wrapperRuntimeException = new WrapperRuntimeException(message, EngineName, EngineVersion,
                                                                      originalMemoryException)
            {
                Description = description
            };

            return(wrapperRuntimeException);
        }
        private static WrapperRuntimeException WrapStatementsCountOverflowException(
            OriginalStatementsCountOverflowException originalStatementsException)
        {
            string description = originalStatementsException.Message;
            string type        = JsErrorType.Range;
            string message     = JsErrorHelpers.GenerateScriptErrorMessage(type, description, string.Empty);

            var wrapperRuntimeException = new WrapperRuntimeException(message, EngineName, EngineVersion,
                                                                      originalStatementsException)
            {
                Description = description
            };

            return(wrapperRuntimeException);
        }
예제 #10
0
        private static WrapperRuntimeException WrapRecursionDepthOverflowException(
            OriginalRecursionDepthOverflowException originalRecursionException)
        {
            string callStack = string.Empty;

            string[] callChainItems = originalRecursionException.CallChain
                                      .Split(new string[] { "->" }, StringSplitOptions.None)
            ;

            if (callChainItems.Length > 0)
            {
                var           stringBuilderPool = StringBuilderPool.Shared;
                StringBuilder stackBuilder      = stringBuilderPool.Rent();

                for (int chainItemIndex = callChainItems.Length - 1; chainItemIndex >= 0; chainItemIndex--)
                {
                    string chainItem = callChainItems[chainItemIndex];
                    if (chainItem == "anonymous function")
                    {
                        chainItem = "Anonymous function";
                    }

                    JsErrorHelpers.WriteErrorLocationLine(stackBuilder, chainItem, string.Empty, 0, 0);
                    if (chainItemIndex > 0)
                    {
                        stackBuilder.AppendLine();
                    }
                }

                callStack = stackBuilder.ToString();
                stringBuilderPool.Return(stackBuilder);
            }

            string description = originalRecursionException.Message;
            string type        = JsErrorType.Range;
            string message     = JsErrorHelpers.GenerateScriptErrorMessage(type, description, callStack);

            var wrapperRuntimeException = new WrapperRuntimeException(message, EngineName, EngineVersion,
                                                                      originalRecursionException)
            {
                Description = description,
                Type        = type,
                CallStack   = callStack
            };

            return(wrapperRuntimeException);
        }
예제 #11
0
        private static WrapperEngineLoadException WrapTypeLoadException(
            TypeLoadException originalTypeLoadException)
        {
            string originalMessage = originalTypeLoadException.Message;
            string description;
            string message;

            Match errorMessageMatch = _libraryLoadErrorMessage.Match(originalMessage);

            if (errorMessageMatch.Success)
            {
                string assemblyFileName = errorMessageMatch.Groups["assemblyFileName"].Value;

                var           stringBuilderPool  = StringBuilderPool.Shared;
                StringBuilder descriptionBuilder = stringBuilderPool.Rent();
                descriptionBuilder.AppendFormat(CoreStrings.Engine_AssemblyNotFound, assemblyFileName);
                descriptionBuilder.Append(" ");

                string packageName;
                if (_nativeAssemblyPackageMap.TryGetValue(assemblyFileName, out packageName))
                {
                    descriptionBuilder.AppendFormat(CoreStrings.Engine_NuGetPackageInstallationRequired, packageName);
                }
                else
                {
                    descriptionBuilder.AppendFormat(CoreStrings.Common_SeeOriginalErrorMessage, originalMessage);
                }

                description = descriptionBuilder.ToString();
                stringBuilderPool.Return(descriptionBuilder);

                message = JsErrorHelpers.GenerateEngineLoadErrorMessage(description, EngineName);
            }
            else
            {
                description = originalMessage;
                message     = JsErrorHelpers.GenerateEngineLoadErrorMessage(description, EngineName, true);
            }

            var wrapperEngineLoadException = new WrapperEngineLoadException(message, EngineName, EngineVersion,
                                                                            originalTypeLoadException)
            {
                Description = description
            };

            return(wrapperEngineLoadException);
        }
예제 #12
0
        /// <summary>
        /// "Compiles" a TypeScript code to JS code
        /// </summary>
        /// <param name="path">Path to TypeScript file</param>
        /// <returns>Compilation result</returns>
        public CompilationResult Compile(string path)
        {
            Initialize();

            CompilationResult compilationResult;

            try
            {
                var result = _jsEngine.Evaluate <string>(string.Format(COMPILATION_FUNCTION_CALL_TEMPLATE,
                                                                       JsonConvert.SerializeObject(path),
                                                                       _optionsString));
                var json = JObject.Parse(result);

                var errors = json["errors"] != null ? json["errors"] as JArray : null;
                if (errors != null && errors.Count > 0)
                {
                    throw new TypeScriptCompilationException(FormatErrorDetails(errors[0], path));
                }

                compilationResult = new CompilationResult
                {
                    CompiledContent   = json.Value <string>("compiledCode"),
                    IncludedFilePaths = json.Value <JArray>("includedFilePaths")
                                        .ToObject <IList <string> >()
                                        .Distinct(StringComparer.OrdinalIgnoreCase)
                                        .Where(p => !p.Equals(path, StringComparison.OrdinalIgnoreCase))
                                        .ToList()
                };
            }
            catch (JsScriptException e)
            {
                string errorDetails = JsErrorHelpers.GenerateErrorDetails(e, true);

                var           stringBuilderPool   = StringBuilderPool.Shared;
                StringBuilder errorMessageBuilder = stringBuilderPool.Rent();
                errorMessageBuilder.AppendLine(e.Message);
                errorMessageBuilder.AppendLine();
                errorMessageBuilder.Append(errorDetails);

                string errorMessage = errorMessageBuilder.ToString();
                stringBuilderPool.Return(errorMessageBuilder);

                throw new TypeScriptCompilationException(errorMessage);
            }

            return(compilationResult);
        }
예제 #13
0
        /// <summary>
        /// "Compiles" Handlebars template to JS code
        /// </summary>
        /// <param name="content">Text content of Handlebars template</param>
        /// <param name="path">Path to Handlebars file</param>
        /// <returns>Translated Handlebars template</returns>
        public string Compile(string content, string path)
        {
            Initialize();

            string newContent;

            try
            {
                var result = _jsEngine.Evaluate <string>(
                    string.Format(COMPILATION_FUNCTION_CALL_TEMPLATE,
                                  JsonConvert.SerializeObject(content),
                                  _optionsString));
                var json = JObject.Parse(result);

                var errors = json["errors"] != null ? json["errors"] as JArray : null;
                if (errors != null && errors.Count > 0)
                {
                    throw new HandlebarsCompilationException(FormatErrorDetails(errors[0], content, path));
                }

                var    compiledCode = json.Value <string>("compiledCode");
                bool   isPartial;
                string templateName = GetTemplateName(path, _options.RootPath, out isPartial);

                newContent = WrapCompiledTemplateCode(compiledCode, _options.Namespace,
                                                      templateName, isPartial);
            }
            catch (JsScriptException e)
            {
                string errorDetails = JsErrorHelpers.GenerateErrorDetails(e, true);

                var           stringBuilderPool   = StringBuilderPool.Shared;
                StringBuilder errorMessageBuilder = stringBuilderPool.Rent();
                errorMessageBuilder.AppendLine(e.Message);
                errorMessageBuilder.AppendLine();
                errorMessageBuilder.Append(errorDetails);

                string errorMessage = errorMessageBuilder.ToString();
                stringBuilderPool.Return(errorMessageBuilder);

                throw new HandlebarsCompilationException(errorMessage);
            }

            return(newContent);
        }
예제 #14
0
        /// <summary>
        /// "Packs" a JS code by using Dean Edwards' Packer
        /// </summary>
        /// <param name="content">Text content of JS asset</param>
        /// <returns>Minified text content of JS asset</returns>
        public string Pack(string content)
        {
            Initialize();

            string newContent;

            try
            {
                newContent = _jsEngine.CallFunction <string>(PACKING_FUNCTION_NAME,
                                                             content, _options.Base62Encode, _options.ShrinkVariables);
            }
            catch (JsRuntimeException e)
            {
                throw new JsPackingException(JsErrorHelpers.Format(e));
            }

            return(newContent);
        }
예제 #15
0
        /// <summary>
        /// Actualizes a vendor prefixes in CSS code by using Andrey Sitnik's Autoprefixer
        /// </summary>
        /// <param name="content">Text content of CSS asset</param>
        /// <param name="path">Path to CSS asset</param>
        /// <returns>Autoprefixing result</returns>
        public AutoprefixingResult Process(string content, string path)
        {
            Initialize();

            AutoprefixingResult autoprefixingResult;

            try
            {
                var result = _jsEngine.Evaluate <string>(
                    string.Format(AUTOPREFIXING_FUNCTION_CALL_TEMPLATE,
                                  JsonConvert.SerializeObject(content), _optionsString));

                var json = JObject.Parse(result);

                var errors = json["errors"] != null ? json["errors"] as JArray : null;
                if (errors != null && errors.Count > 0)
                {
                    throw new CssAutoprefixingException(FormatErrorDetails(errors[0], content, path));
                }

                autoprefixingResult = new AutoprefixingResult
                {
                    ProcessedContent  = json.Value <string>("processedCode"),
                    IncludedFilePaths = GetIncludedFilePaths(_options.Stats)
                };
            }
            catch (JsScriptException e)
            {
                string errorDetails = JsErrorHelpers.GenerateErrorDetails(e, true);

                var           stringBuilderPool   = StringBuilderPool.Shared;
                StringBuilder errorMessageBuilder = stringBuilderPool.Rent();
                errorMessageBuilder.AppendLine(e.Message);
                errorMessageBuilder.AppendLine();
                errorMessageBuilder.Append(errorDetails);

                string errorMessage = errorMessageBuilder.ToString();
                stringBuilderPool.Return(errorMessageBuilder);

                throw new CssAutoprefixingException(errorMessage);
            }

            return(autoprefixingResult);
        }
예제 #16
0
 public static string UnmaskFrom(string maskedUrl, string userId)
 {
     try
     {
         using (var jsEngine = new MsieJsEngine())
         {
             jsEngine.ExecuteResource("VkAudioSync.Vk.audioUnmask.js", Assembly.GetExecutingAssembly());
             return(jsEngine.Evaluate <string>($"unmaskUrl(\"{maskedUrl}\", {userId});"));
         }
     }
     catch (JsEngineLoadException e)
     {
         throw new Exception($"JS Compile error: {JsErrorHelpers.Format(e)}");
     }
     catch (JsRuntimeException e)
     {
         throw new Exception($"JS Runtime error: {JsErrorHelpers.Format(e)}");
     }
 }
        /// <summary>
        /// Constructs an instance of adapter for the Vroom JS engine
        /// (cross-platform bridge to the V8 JS engine)
        /// </summary>
        /// <param name="settings">Settings of the Vroom JS engine</param>
        public VroomJsEngine(VroomSettings settings)
        {
            Initialize();

            VroomSettings vroomSettings = settings ?? new VroomSettings();

            try
            {
                _jsEngine  = new OriginalEngine(vroomSettings.MaxYoungSpaceSize, vroomSettings.MaxOldSpaceSize);
                _jsContext = _jsEngine.CreateContext();
            }
            catch (TypeInitializationException e)
            {
                Exception innerException = e.InnerException;
                if (innerException != null)
                {
                    var dllNotFoundException = innerException as DllNotFoundException;
                    if (dllNotFoundException != null)
                    {
                        throw WrapDllNotFoundException(dllNotFoundException);
                    }
                    else
                    {
                        throw JsErrorHelpers.WrapEngineLoadException(innerException, EngineName, EngineVersion,
                                                                     true);
                    }
                }

                throw JsErrorHelpers.WrapEngineLoadException(e, EngineName, EngineVersion, true);
            }
            catch (Exception e)
            {
                throw JsErrorHelpers.WrapEngineLoadException(e, EngineName, EngineVersion, true);
            }
            finally
            {
                if (_jsContext == null)
                {
                    Dispose();
                }
            }
        }
예제 #18
0
        /// <summary>
        /// Constructs an instance of adapter for the NiL JS engine
        /// </summary>
        /// <param name="settings">Settings of the NiL JS engine</param>
        public NiLJsEngine(NiLSettings settings)
        {
            NiLSettings niLSettings = settings ?? new NiLSettings();

            _debuggerCallback = niLSettings.DebuggerCallback;

            try
            {
                _jsContext           = new OriginalContext(niLSettings.StrictMode);
                _jsContext.Debugging = niLSettings.EnableDebugging;
                if (_debuggerCallback != null)
                {
                    _jsContext.DebuggerCallback += _debuggerCallback;
                }
            }
            catch (Exception e)
            {
                throw JsErrorHelpers.WrapEngineLoadException(e, EngineName, EngineVersion, true);
            }
        }
        /// <summary>
        /// Constructs an instance of adapter for the Jurassic JS engine
        /// </summary>
        /// <param name="settings">Settings of the Jurassic JS engine</param>
        public JurassicJsEngine(JurassicSettings settings)
        {
            JurassicSettings jurassicSettings = settings ?? new JurassicSettings();

            try
            {
                _jsEngine = new OriginalEngine
                {
                    CompatibilityMode = OriginalCompatibilityMode.Latest,
                    DisableClrCollectionsExposingByValue = !jurassicSettings.EnableHostCollectionsEmbeddingByValue,
                    EnableExposedClrTypes = true,
                    EnableILAnalysis      = jurassicSettings.EnableIlAnalysis,
                    ForceStrictMode       = jurassicSettings.StrictMode
                };
            }
            catch (Exception e)
            {
                throw JsErrorHelpers.WrapEngineLoadException(e, EngineName, EngineVersion, true);
            }
        }
        /// <summary>
        /// "Compiles" CoffeeScript code to JS code
        /// </summary>
        /// <param name="content">Text content written on CoffeeScript</param>
        /// <param name="path">Path to CoffeeScript file</param>
        /// <returns>Translated CoffeeScript code</returns>
        public string Compile(string content, string path)
        {
            Initialize();

            string newContent;
            string optionsString = ConvertCompilationOptionsToJson(path, _options).ToString();

            try
            {
                var result = _jsEngine.Evaluate <string>(
                    string.Format(COMPILATION_FUNCTION_CALL_TEMPLATE,
                                  JsonConvert.SerializeObject(content),
                                  optionsString));
                var json = JObject.Parse(result);

                var errors = json["errors"] != null ? json["errors"] as JArray : null;
                if (errors != null && errors.Count > 0)
                {
                    throw new CoffeeScriptCompilationException(FormatErrorDetails(errors[0], content, path));
                }

                newContent = json.Value <string>("compiledCode");
            }
            catch (JsScriptException e)
            {
                string errorDetails = JsErrorHelpers.GenerateErrorDetails(e, true);

                var           stringBuilderPool   = StringBuilderPool.Shared;
                StringBuilder errorMessageBuilder = stringBuilderPool.Rent();
                errorMessageBuilder.AppendLine(e.Message);
                errorMessageBuilder.AppendLine();
                errorMessageBuilder.Append(errorDetails);

                string errorMessage = errorMessageBuilder.ToString();
                stringBuilderPool.Return(errorMessageBuilder);

                throw new CoffeeScriptCompilationException(errorMessage);
            }

            return(newContent);
        }
        private static WrapperCompilationException WrapSyntaxException(
            OriginalSyntaxException originalSyntaxException)
        {
            string description  = originalSyntaxException.Message;
            string type         = JsErrorType.Syntax;
            string documentName = originalSyntaxException.SourcePath;
            int    lineNumber   = originalSyntaxException.LineNumber;
            string message      = JsErrorHelpers.GenerateScriptErrorMessage(type, description, documentName,
                                                                            lineNumber, 0);

            var wrapperCompilationException = new WrapperCompilationException(message, EngineName, EngineVersion,
                                                                              originalSyntaxException)
            {
                Description  = description,
                Type         = type,
                DocumentName = documentName,
                LineNumber   = lineNumber
            };

            return(wrapperCompilationException);
        }
예제 #22
0
        /// <summary>
        /// Constructs an instance of adapter for the Jint JS engine
        /// </summary>
        /// <param name="settings">Settings of the Jint JS engine</param>
        public JintJsEngine(JintSettings settings)
        {
            JintSettings jintSettings = settings ?? new JintSettings();

            try
            {
                _jsEngine = new OriginalEngine(c => c
                                               .AllowDebuggerStatement(jintSettings.AllowDebuggerStatement)
                                               .DebugMode(jintSettings.EnableDebugging)
                                               .LimitRecursion(jintSettings.MaxRecursionDepth)
                                               .LocalTimeZone(jintSettings.LocalTimeZone ?? TimeZoneInfo.Local)
                                               .MaxStatements(jintSettings.MaxStatements)
                                               .Strict(jintSettings.StrictMode)
                                               .TimeoutInterval(jintSettings.TimeoutInterval)
                                               );
            }
            catch (Exception e)
            {
                throw JsErrorHelpers.WrapEngineLoadException(e, EngineName, EngineVersion, true);
            }
        }
예제 #23
0
        /// <summary>
        /// "Cleans" CSS code by using Clean-css
        /// </summary>
        /// <param name="content">Text content of CSS asset</param>
        /// <param name="path">Path to CSS file</param>
        /// <returns>Minified text content of CSS asset</returns>
        public string Clean(string content, string path)
        {
            Initialize();

            string newContent;

            try
            {
                var result = _jsEngine.Evaluate <string>(
                    string.Format(CLEANING_FUNCTION_CALL_TEMPLATE,
                                  JsonConvert.SerializeObject(content), _optionsString));

                var json = JObject.Parse(result);

                var errors = json["errors"] != null ? json["errors"] as JArray : null;
                if (errors != null && errors.Count > 0)
                {
                    throw new CssCleaningException(FormatErrorDetails(errors[0].Value <string>(), true,
                                                                      path));
                }

                if (_options.Severity > 0)
                {
                    var warnings = json["warnings"] != null ? json["warnings"] as JArray : null;
                    if (warnings != null && warnings.Count > 0)
                    {
                        throw new CssCleaningException(FormatErrorDetails(warnings[0].Value <string>(),
                                                                          false, path));
                    }
                }

                newContent = json.Value <string>("minifiedCode");
            }
            catch (JsRuntimeException e)
            {
                throw new CssCleaningException(JsErrorHelpers.Format(e));
            }

            return(newContent);
        }
        /// <summary>
        /// Constructs an instance of adapter for the Jurassic JS engine
        /// </summary>
        /// <param name="settings">Settings of the Jurassic JS engine</param>
        public JurassicJsEngine(JurassicSettings settings)
        {
            JurassicSettings jurassicSettings = settings ?? new JurassicSettings();

            try
            {
                _jsEngine = new OriginalEngine
                {
#if !NETSTANDARD2_0
                    EnableDebugging = jurassicSettings.EnableDebugging,
#endif
                    CompatibilityMode     = OriginalCompatibilityMode.Latest,
                    EnableExposedClrTypes = true,
                    EnableILAnalysis      = jurassicSettings.EnableIlAnalysis,
                    ForceStrictMode       = jurassicSettings.StrictMode
                };
            }
            catch (Exception e)
            {
                throw JsErrorHelpers.WrapEngineLoadException(e, EngineName, EngineVersion, true);
            }
        }
        private static WrapperCompilationException WrapParserException(OriginalParserException originalParserException)
        {
            string description  = originalParserException.Description;
            string type         = JsErrorType.Syntax;
            string documentName = originalParserException.SourceText;
            int    lineNumber   = originalParserException.LineNumber;
            int    columnNumber = originalParserException.Column;
            string message      = JsErrorHelpers.GenerateScriptErrorMessage(type, description, documentName, lineNumber,
                                                                            columnNumber);

            var wrapperCompilationException = new WrapperCompilationException(message, EngineName, EngineVersion,
                                                                              originalParserException)
            {
                Description  = description,
                Type         = type,
                DocumentName = documentName,
                LineNumber   = lineNumber,
                ColumnNumber = columnNumber
            };

            return(wrapperCompilationException);
        }
예제 #26
0
        /// <summary>
        /// "Compiles" a TypeScript code to JS code
        /// </summary>
        /// <param name="path">Path to TypeScript file</param>
        /// <returns>Compilation result</returns>
        public CompilationResult Compile(string path)
        {
            Initialize();

            CompilationResult compilationResult;

            try
            {
                var result = _jsEngine.Evaluate <string>(string.Format(COMPILATION_FUNCTION_CALL_TEMPLATE,
                                                                       JsonConvert.SerializeObject(path),
                                                                       _optionsString));
                var json = JObject.Parse(result);

                var errors = json["errors"] != null ? json["errors"] as JArray : null;
                if (errors != null && errors.Count > 0)
                {
                    throw new TypeScriptCompilationException(FormatErrorDetails(errors[0], path));
                }

                compilationResult = new CompilationResult
                {
                    CompiledContent   = json.Value <string>("compiledCode"),
                    IncludedFilePaths = json.Value <JArray>("includedFilePaths")
                                        .ToObject <IList <string> >()
                                        .Distinct(StringComparer.OrdinalIgnoreCase)
                                        .Where(p => !p.Equals(path, StringComparison.OrdinalIgnoreCase))
                                        .ToList()
                };
            }
            catch (JsRuntimeException e)
            {
                throw new TypeScriptCompilationException(JsErrorHelpers.Format(e));
            }

            return(compilationResult);
        }
        /// <summary>
        /// Returns a string that represents the current exception
        /// </summary>
        /// <returns>A string that represents the current exception</returns>
        public override string ToString()
        {
            string errorDetails = JsErrorHelpers.GenerateErrorDetails(this, true);

            var           stringBuilderPool = StringBuilderPool.Shared;
            StringBuilder resultBuilder     = stringBuilderPool.Rent();

            resultBuilder.Append(this.GetType().FullName);
            resultBuilder.Append(": ");
            resultBuilder.Append(this.Message);

            if (errorDetails.Length > 0)
            {
                resultBuilder.AppendLine();
                resultBuilder.AppendLine();
                resultBuilder.Append(errorDetails);
            }

            if (this.InnerException != null)
            {
                resultBuilder.Append(" ---> ");
                resultBuilder.Append(this.InnerException.ToString());
            }

            if (this.StackTrace != null)
            {
                resultBuilder.AppendLine();
                resultBuilder.AppendLine(this.StackTrace);
            }

            string result = resultBuilder.ToString();

            stringBuilderPool.Return(resultBuilder);

            return(result);
        }
        /// <summary>
        /// Constructs an instance of adapter for the Jint JS engine
        /// </summary>
        /// <param name="settings">Settings of the Jint JS engine</param>
        public JintJsEngine(JintSettings settings)
        {
            _cancellationTokenSource = new CancellationTokenSource();
            _cancellationConstraint  = new OriginalCancellationConstraint(_cancellationTokenSource.Token);

            JintSettings jintSettings = settings ?? new JintSettings();

            try
            {
                _jsEngine = new OriginalEngine(options => {
                    options
                    .AllowDebuggerStatement(jintSettings.AllowDebuggerStatement)
                    .WithoutConstraint(c => c is OriginalCancellationConstraint)
                    .Constraint(_cancellationConstraint)
                    .DebugMode(jintSettings.EnableDebugging)
                    .LimitMemory(jintSettings.MemoryLimit)
                    .LimitRecursion(jintSettings.MaxRecursionDepth)
                    .LocalTimeZone(jintSettings.LocalTimeZone ?? TimeZoneInfo.Local)
                    .MaxStatements(jintSettings.MaxStatements)
                    .Strict(jintSettings.StrictMode)
                    .TimeoutInterval(jintSettings.TimeoutInterval)
                    ;

                    if (jintSettings.RegexTimeoutInterval.HasValue)
                    {
                        options.RegexTimeoutInterval(jintSettings.RegexTimeoutInterval.Value);
                    }

                    options.AddObjectConverter(new UndefinedConverter());
                });
            }
            catch (Exception e)
            {
                throw JsErrorHelpers.WrapEngineLoadException(e, EngineName, EngineVersion, true);
            }
        }
예제 #29
0
        private JsValue CreateFunctionFromDelegate(Delegate value)
        {
            JsNativeFunction nativeFunction = (callee, isConstructCall, args, argCount, callbackData) =>
            {
                object[]        processedArgs  = MapToHostType(args.Skip(1).ToArray());
                ParameterInfo[] parameters     = value.GetMethodInfo().GetParameters();
                JsValue         undefinedValue = JsValue.Undefined;

                ReflectionHelpers.FixArgumentTypes(ref processedArgs, parameters);

                object result;

                try
                {
                    result = value.DynamicInvoke(processedArgs);
                }
                catch (Exception e)
                {
                    JsValue errorValue = JsErrorHelpers.CreateError(
                        string.Format(Strings.Runtime_HostDelegateInvocationFailed, e.Message));
                    JsErrorHelpers.SetException(errorValue);

                    return(undefinedValue);
                }

                JsValue resultValue = MapToScriptType(result);

                return(resultValue);
            };

            _nativeFunctions.Add(nativeFunction);

            JsValue functionValue = JsValue.CreateFunction(nativeFunction);

            return(functionValue);
        }
예제 #30
0
        private static WrapperException WrapJsException(OriginalException originalException)
        {
            WrapperException wrapperException;
            string           message     = originalException.Message;
            string           description = message;
            string           type        = string.Empty;
            int    lineNumber            = 0;
            int    columnNumber          = 0;
            string sourceFragment        = string.Empty;

            var errorValue = originalException.Error?.Value as OriginalError;

            if (errorValue != null)
            {
                message     = errorValue.message.As <string>();
                description = message;
                type        = errorValue.name.As <string>();
            }

            if (!string.IsNullOrEmpty(type))
            {
                WrapperScriptException wrapperScriptException;
                if (type == JsErrorType.Syntax)
                {
                    Match messageMatch = _syntaxErrorMessageRegex.Match(message);
                    if (messageMatch.Success)
                    {
                        GroupCollection messageGroups = messageMatch.Groups;
                        description  = messageGroups["description"].Value;
                        lineNumber   = int.Parse(messageGroups["lineNumber"].Value);
                        columnNumber = int.Parse(messageGroups["columnNumber"].Value);
                    }
                    message = JsErrorHelpers.GenerateScriptErrorMessage(type, description, string.Empty,
                                                                        lineNumber, columnNumber);

                    wrapperScriptException = new WrapperCompilationException(message, EngineName, EngineVersion,
                                                                             originalException);
                }
                else
                {
                    string sourceCode = originalException.Code;
                    OriginalCodeCoordinates codeCoordinates = originalException.CodeCoordinates;
                    if (codeCoordinates != null)
                    {
                        lineNumber   = codeCoordinates.Line;
                        columnNumber = codeCoordinates.Column;
                    }
                    sourceFragment = TextHelpers.GetTextFragment(sourceCode, lineNumber, columnNumber);
                    message        = JsErrorHelpers.GenerateScriptErrorMessage(type, description, string.Empty,
                                                                               lineNumber, columnNumber, sourceFragment);

                    wrapperScriptException = new WrapperRuntimeException(message, EngineName, EngineVersion,
                                                                         originalException);
                }
                wrapperScriptException.Type           = type;
                wrapperScriptException.LineNumber     = lineNumber;
                wrapperScriptException.ColumnNumber   = columnNumber;
                wrapperScriptException.SourceFragment = sourceFragment;

                wrapperException = wrapperScriptException;
            }
            else
            {
                wrapperException = new WrapperException(message, EngineName, EngineVersion, originalException);
            }

            wrapperException.Description = description;

            return(wrapperException);
        }