public string CompressContent(string content) { var minifier = new Minifier(); if (settings != null) { return minifier.MinifyStyleSheet(content, settings); } return minifier.MinifyStyleSheet(content); }
public string Minify(string content) { var minifier = new Minifier(); var stylesheet = string.Empty; stylesheet = Settings != null ? minifier.MinifyStyleSheet(content, Settings) : minifier.MinifyStyleSheet(content); return stylesheet; }
public static void ExtractCore(Translator translatorInstance, string outputPath, bool nodebug = false) { var clrPath = translatorInstance.BridgeLocation; var assembly = System.Reflection.Assembly.UnsafeLoadFrom(clrPath); // We can only have Beautified, Minified or Both, so this test has inverted logic: // output beautified if not minified only == (output beautified or output both) if (translatorInstance.AssemblyInfo.OutputFormatting != JavaScriptOutputType.Minified) { ExtractResourceAndWriteToFile(outputPath, assembly, "Bridge.Resources.bridge.js", "bridge.js"); } if (translatorInstance.AssemblyInfo.GenerateTypeScript) { ExtractResourceAndWriteToFile(outputPath, assembly, "Bridge.Resources.bridge.d.ts", "bridge.d.ts"); } // Like above test: output minified if not beautified only == (out minified or out both) if (translatorInstance.AssemblyInfo.OutputFormatting != JavaScriptOutputType.Formatted) { if (!nodebug) { ExtractResourceAndWriteToFile(outputPath, assembly, "Bridge.Resources.bridge.js", "bridge.min.js", (reader) => { var minifier = new Minifier(); return minifier.MinifyJavaScript(reader.ReadToEnd(), new CodeSettings { TermSemicolons = true }); }); } } }
public override IEnumerable<PvcCore.PvcStream> Execute(IEnumerable<PvcCore.PvcStream> inputStreams) { var minifyStreams = inputStreams.Where(x => Regex.IsMatch(x.StreamName, @"\.(js|css)$")); var resultStreams = new List<PvcStream>(); foreach (var inputStream in minifyStreams) { var fileContent = new StreamReader(inputStream).ReadToEnd(); var minifier = new Minifier(); var resultContent = inputStream.StreamName.EndsWith(".js") ? minifier.MinifyJavaScript(fileContent) : minifier.MinifyStyleSheet(fileContent); foreach (var error in minifier.ErrorList) { Console.Error.WriteLine(error.ToString()); } var dirName = Path.GetDirectoryName(inputStream.StreamName); var fileName = Path.GetFileNameWithoutExtension(inputStream.StreamName) + ".min" + Path.GetExtension(inputStream.StreamName); var resultStream = PvcUtil.StringToStream(resultContent, Path.Combine(dirName, fileName)); resultStreams.Add(resultStream); } return inputStreams.Where(x => !minifyStreams.Any(y => y.StreamName == x.StreamName)).Concat(resultStreams); }
public MinifierManager(CommandLineOptions cmdLineOptions) : base(cmdLineOptions) { _minifier = new Minifier(); SetupDependencies(); StartListener(); }
public string Compile(IEnumerable<string> files) { var blocks = new List<Block>(); // ReSharper disable once LoopCanBeConvertedToQuery foreach (string file in files) { var parser = new JSParser(File.ReadAllText(file)) { FileContext = file }; var block = parser.Parse(new CodeSettings { EvalTreatment = EvalTreatment.MakeImmediateSafe, PreserveImportantComments = false }); if (block != null) { blocks.Add(block); } } Block fst = blocks[0]; for (int i = 1; i < blocks.Count; i++) { fst.Append(blocks[i]); } string sequenceCode = fst.ToCode(); var minifier = new Minifier(); string compiled = minifier.MinifyJavaScript( sequenceCode, new CodeSettings { EvalTreatment = EvalTreatment.MakeImmediateSafe, PreserveImportantComments = false }); return compiled; }
/// <summary> /// Minifies the specified CSS. /// </summary> /// <param name="resource">The CSS to minify.</param> /// <returns>The minified CSS, if minification was successful; otherwise, the original CSS with minification errors appended at the end.</returns> public string Minify(string resource) { if (String.IsNullOrEmpty(resource)) { return resource; } var settings = new CssSettings { AllowEmbeddedAspNetBlocks = false }; var minifier = new Minifier(); try { resource = minifier.MinifyStyleSheet(resource, settings); } catch { var minificationErrors = String.Join(Environment.NewLine, minifier.Errors); resource = AppendMinificationErrors(resource, minificationErrors); if (mLogErrors) { CoreServices.EventLog.LogEvent("W", "Resource minification", "CssMinificationFailed", minificationErrors); } } return resource; }
private static void MinifyFile(string file, string minFile, CodeSettings settings, bool isBundle) { Minifier minifier = new Minifier(); if (!isBundle) { minifier.FileName = Path.GetFileName(file); } string content = minifier.MinifyJavaScript(File.ReadAllText(file), settings); if (File.Exists(minFile) && content == File.ReadAllText(minFile)) return; if (WESettings.GetBoolean(WESettings.Keys.GenerateJavaScriptSourceMaps)) { content += "\r\n/*\r\n//# sourceMappingURL=" + Path.GetFileName(minFile) + ".map\r\n*/"; } ProjectHelpers.CheckOutFileFromSourceControl(minFile); using (StreamWriter writer = new StreamWriter(minFile, false, new UTF8Encoding(true))) { writer.Write(content); } if (WESettings.GetBoolean(WESettings.Keys.JavaScriptEnableGzipping)) CssSaveListener.GzipFile(file, minFile, content); }
private static MinificationResult MinifyJavaScript(Config config, string file) { string content = File.ReadAllText(file); var settings = JavaScriptOptions.GetSettings(config); if (config.Minify.ContainsKey("enabled") && config.Minify["enabled"].ToString().Equals("false", StringComparison.OrdinalIgnoreCase)) return null; var minifier = new Minifier(); string ext = Path.GetExtension(file); string minFile = file.Substring(0, file.LastIndexOf(ext)) + ".min" + ext; string mapFile = minFile + ".map"; string result = minifier.MinifyJavaScript(content, settings); bool containsChanges = FileHelpers.HasFileContentChanged(minFile, result); if (!string.IsNullOrEmpty(result)) { OnBeforeWritingMinFile(file, minFile, containsChanges); if (containsChanges) { File.WriteAllText(minFile, result, new UTF8Encoding(true)); } OnAfterWritingMinFile(file, minFile, containsChanges); GzipFile(config, minFile, containsChanges); } return new MinificationResult(result, null); }
private static MinificationResult MinifyCss(Config config, string file) { string content = File.ReadAllText(file); var settings = CssOptions.GetSettings(config); if (config.Minify.ContainsKey("enabled") && config.Minify["enabled"].ToString().Equals("false", StringComparison.OrdinalIgnoreCase)) return null; var minifier = new Minifier(); // Remove control characters which AjaxMin can't handle content = Regex.Replace(content, @"[\u0000-\u0009\u000B-\u000C\u000E-\u001F]", string.Empty); string result = minifier.MinifyStyleSheet(content, settings); string minFile = GetMinFileName(file); bool containsChanges = FileHelpers.HasFileContentChanged(minFile, result); OnBeforeWritingMinFile(file, minFile, containsChanges); if (containsChanges) { File.WriteAllText(minFile, result, new UTF8Encoding(true)); } OnAfterWritingMinFile(file, minFile, containsChanges); GzipFile(config, minFile, containsChanges); return new MinificationResult(result, null); }
public static string MinifyString(string extension, string content) { if (extension == ".css") { Minifier minifier = new Minifier(); CssSettings settings = new CssSettings(); settings.CommentMode = CssComment.None; if (WESettings.GetBoolean(WESettings.Keys.KeepImportantComments)) { settings.CommentMode = CssComment.Important; } return minifier.MinifyStyleSheet(content, settings); } else if (extension == ".js") { Minifier minifier = new Minifier(); CodeSettings settings = new CodeSettings() { EvalTreatment = EvalTreatment.MakeImmediateSafe, PreserveImportantComments = WESettings.GetBoolean(WESettings.Keys.KeepImportantComments) }; return minifier.MinifyJavaScript(content, settings); } return null; }
protected override void BuildResult(Stream fs, List <string> filePaths) { var minifier = new Microsoft.Ajax.Utilities.Minifier(); minifier.WarningLevel = 3; var styleBuilder = new StringBuilder(); foreach (var style in filePaths) { var text = FileOperator.ReadAllText(style); try { var mintext = minifier.MinifyStyleSheet(text); if (minifier.Errors.Count == 0) { text = mintext; } } catch (Exception) { } styleBuilder.AppendLine(text); } var buffer = Encoding.UTF8.GetBytes(styleBuilder.ToString()); fs.Write(buffer, 0, buffer.Length); }
protected override void BuildResult(Stream fs, List <string> filePaths) { var minifier = new Microsoft.Ajax.Utilities.Minifier(); minifier.WarningLevel = 3; var styleBuilder = new StringBuilder(); foreach (var style in filePaths) { var text = FileOperator.ReadAllText(style); if (style.IndexOf(".min.") == -1) { try { var mintext = minifier.MinifyJavaScript(text); text = mintext; } catch (Exception) { } } styleBuilder.Append(';'); styleBuilder.AppendLine(text); } var buffer = Encoding.UTF8.GetBytes(styleBuilder.ToString()); fs.Write(buffer, 0, buffer.Length); }
public string Minify(string content) { var minifer = new Minifier(); codeSettings = codeSettings ?? new CodeSettings(); codeSettings.SetKnownGlobalNames(globalNames); return minifer.MinifyJavaScript(content, codeSettings); }
/// <summary> /// (Awaitable) Compiles content with the give configuration (files and minify flag). /// </summary> /// <param name="content">Content to Compile</param> /// <param name="minify"></param> /// <returns>string with compiled content</returns> public Task<string> CompileAsync(string content, bool minify) { if (!minify) return Task.FromResult(content); var minifier = new Minifier(); return Task.FromResult(minifier.MinifyJavaScript(content)); }
/// <summary> /// Minifies the CSS. /// </summary> /// <param name="css">The CSS.</param> /// <returns></returns> public static String MinifyCss(String css) { if (String.IsNullOrWhiteSpace(css)) return css; var min = new Minifier(); return min.MinifyStyleSheet(css); //return Yahoo.Yui.Compressor.CssCompressor.Compress(css); }
public string CompressContent(string content, bool removeComments) { var settings = new CssSettings(); if(removeComments) settings.CommentMode = CssComment.None; var minifier = new Minifier(); return minifier.MinifyStyleSheet(content, settings); }
public string Compress(string content) { var cssSettings = new CssSettings(); cssSettings.ColorNames = CssColor.Hex; cssSettings.ExpandOutput = false; var value = new Minifier().MinifyStyleSheet(content, cssSettings); return value; }
public void Minify() { var minifer = new Minifier(); var codeSettings = new CodeSettings(); var content = _fileSystem.BundleFiles(_files); var minified = minifer.MinifyJavaScript(content, codeSettings); _fileSystem.File.WriteAllText(_outputPath, minified); }
protected override string Compress(string source) { var minifier = new Minifier(); var minified = minifier.MinifyJavaScript(source); if (minifier.Errors.Count > 0) { return source; } return minified; }
public string Minify(string source) { CodeSettings settings = new CodeSettings { PreserveImportantComments = false, PreserveFunctionNames = true }; Minifier doMin = new Minifier(); string mind = doMin.MinifyJavaScript(source, settings); return mind; }
private static void Generate(string outputPath, bool minify, Minifier minifier, string js) { if (minify) { File.WriteAllText(outputPath, minifier.MinifyJavaScript(js)); } else { File.WriteAllText(outputPath, js); } }
public Func<Stream> Transform(Func<Stream> openSourceStream, IAsset asset) { return delegate { using (var reader = new StreamReader(openSourceStream())) { var output = new Minifier().MinifyStyleSheet(reader.ReadToEnd(), cssSettings); return output.AsStream(); } }; }
public string CompressContent(string content) { var minifer = new Minifier(); if (codeSettings != null) { return minifer.MinifyJavaScript(content, codeSettings, globalNames); } else { return minifer.MinifyJavaScript(content, globalNames); } }
public override void Process(BundleContext context, BundleResponse response) { response.ContentType = ContentType.JavaScript; if (context.HttpContext.IsDebuggingEnabled) { return; } var minifier = new Minifier(); response.Content = minifier.MinifyJavaScript(response.Content); }
public void Write(Module module) { var minifier = new Minifier(); textWriter.Write( minifier.MinifyJavaScript( string.Join( "\r\n", module.Resources.Select(s => GetJavaScript(rootDirectory + s.Path)) ) ) ); }
public void Write(Module module) { var minifier = new Minifier(); textWriter.Write( minifier.MinifyStyleSheet( string.Join( "\r\n", module.Resources.Select(ReadCss) ) ) ); }
public void ProcessRequest(HttpContext context) { _context = context; Map("~/Client/routes/", BuildName); Map("~/Client/controls/", file => String.Format("controls/{0}", Path.GetFileNameWithoutExtension(file))); var minifier = new Minifier(); context.Response.ContentType = "text/javascript"; var content = minifier.MinifyJavaScript(_builder.ToString()); context.Response.Write(minifier.ErrorList.Any() ? _builder.ToString() : content); context.Response.End(); }
static void Main(string[] args) { bool minify = false; bool absolute = false; if (args.Length < 1) { Console.WriteLine("Usage: {0} [url] (/minify) (/absolute)", typeof(Program).Assembly.GetName().Name); return; } ParseArguments(args, out minify, out absolute); string url = args[0]; string baseUrl = null; if (!url.EndsWith("/")) { url += "/"; } if(!url.EndsWith("signalr")) { url += "signalr/"; } baseUrl = url; if (!url.EndsWith("hubs", StringComparison.OrdinalIgnoreCase)) { url += "hubs"; } var uri = new Uri(url); var minifier = new Minifier(); var wc = new WebClient(); string js = wc.DownloadString(uri); if (absolute) { js = Regex.Replace(js, @"\(""(.*?/signalr)""\)", m => "(\"" + baseUrl + "\")"); } if (minify) { Console.WriteLine(minifier.MinifyJavaScript(js)); } else { Console.WriteLine(js); } }
public static string MinifyString(string extension, string content) { if (extension == ".css") { Minifier minifier = new Minifier(); CssSettings settings = new CssSettings(); settings.CommentMode = CssComment.None; if (WESettings.GetBoolean(WESettings.Keys.KeepImportantComments)) { settings.CommentMode = CssComment.Important; } return minifier.MinifyStyleSheet(content, settings); } else if (extension == ".js") { Minifier minifier = new Minifier(); CodeSettings settings = new CodeSettings() { EvalTreatment = EvalTreatment.MakeImmediateSafe, PreserveImportantComments = WESettings.GetBoolean(WESettings.Keys.KeepImportantComments) }; return minifier.MinifyJavaScript(content, settings); } else if (_htmlExt.Contains(extension.ToLowerInvariant())){ var settings = new HtmlMinificationSettings { RemoveOptionalEndTags = false, AttributeQuotesRemovalMode = HtmlAttributeQuotesRemovalMode.KeepQuotes }; var minifier = new HtmlMinifier(settings); MarkupMinificationResult result = minifier.Minify(content, generateStatistics: true); if (result.Errors.Count == 0) { EditorExtensionsPackage.DTE.StatusBar.Text = "Web Essentials: HTML minified by " + result.Statistics.SavedInPercent + "%"; return result.MinifiedContent; } else { EditorExtensionsPackage.DTE.StatusBar.Text = "Web Essentials: Cannot minify the current selection"; return content; } } return null; }
/// <summary> /// Compressed the javascript content /// </summary> /// <param name="value"></param> /// <returns></returns> public string Compress(string content) { // The CodeSettings object specifies how the content // will be minified var codeSettings = new CodeSettings(); codeSettings.RemoveUnneededCode = true; codeSettings.LocalRenaming = LocalRenaming.CrunchAll; codeSettings.OutputMode = OutputMode.SingleLine; codeSettings.StripDebugStatements = true; codeSettings.IndentSize = 0; var value = new Minifier().MinifyJavaScript(content, codeSettings); return value; }
private static string MinifyJavaScript(string input) { Minifier minifier = new Minifier(); CodeSettings settings = new CodeSettings(); settings.RemoveUnneededCode = false; settings.PreserveFunctionNames = true; string output = minifier.MinifyJavaScript(input, settings); if (!String.IsNullOrEmpty(output)) { output = output + ";"; } return output; }
private void minifyCSS(Entity entity, CssSettings settings) { Microsoft.Ajax.Utilities.Minifier minifier = new Microsoft.Ajax.Utilities.Minifier(); string name = entity.GetAttributeValue <string>("displayname"); byte[] cssFileBytes = Convert.FromBase64String(entity.GetAttributeValue <string>("content")); string originalCss = UnicodeEncoding.UTF8.GetString(cssFileBytes); string minifiedCss = minifier.MinifyStyleSheet(originalCss, settings); byte[] minifiedCssBytes = UnicodeEncoding.UTF8.GetBytes(minifiedCss); string minifiedCssBytesString = Convert.ToBase64String(minifiedCssBytes); Entity updatedWebResource = new Entity(entity.LogicalName); updatedWebResource.Attributes.Add("content", minifiedCssBytesString); updatedWebResource.Id = entity.Id; this.service.Update(updatedWebResource); }
/// <summary> /// Main Method (Entry point to the program). /// </summary> /// <param name="args"></param> static void Main(string[] args) { /// instantiate a code settings object. CodeSettings cs = new CodeSettings(); cs.QuoteObjectLiteralProperties = true; cs.PreserveImportantComments = false; /// Extract the bookmarklet wrapper javascript from the js wrapper file. /// This file is the defines the bookmarklet javascript entry point and wraps each bookmarklet within this javascript. string bookmarkletMainJSWrapper = System.IO.File.ReadAllText(Properties.Settings.Default.BookmarkletMainJSWrapper); /// Read all the HTML Template file for adding the bookmarklets as links into. string htmlTemplate = System.IO.File.ReadAllText(Properties.Settings.Default.BookmarkletHtmlTemplate); string importableTemplate = System.IO.File.ReadAllText(Properties.Settings.Default.BookmarkletHtmlImportableTemplate); /// A list of all the bookarklets from the bookmarklets folder List <Bookmarklet> bookmarklets = new List <Bookmarklet>(); #region Load all bookmarklets /// For each bookmarklet js in the bookmarklets folder foreach (string file in System.IO.Directory.GetFiles(Properties.Settings.Default.BookmarkletsFolder)) { /// get the file info FileInfo fi = new FileInfo(file); // if the file is not a js file skip if (fi.Extension.ToLower() != ".js") { continue; } /// Instantite the bookmarklet object populating all the properties Bookmarklet bookmarklet = new Bookmarklet(); bookmarklet.Name = fi.Name.Replace(".js", ""); bookmarklet.javascript = System.IO.File.ReadAllText(file); /// Extract the bookmarklet info from the xml documentation notation int firstIndex = bookmarklet.javascript.IndexOf("<BookmarkletInfo>"); int lastindex = bookmarklet.javascript.LastIndexOf("</BookmarkletInfo>") + ("</BookmarkletInfo>").Length; if (firstIndex > 0) { string bookmarkletInfo = bookmarklet.javascript.Substring(firstIndex, lastindex - firstIndex); XDocument doc = XDocument.Parse(bookmarkletInfo); var nameNode = doc.XPathSelectElement("/BookmarkletInfo/Name"); if (nameNode != null) { bookmarklet.Name = nameNode.Value.ToString().Trim(); } var descriptionNode = doc.XPathSelectElement("/BookmarkletInfo/Description"); if (descriptionNode != null) { bookmarklet.Description = InnerXml(descriptionNode).Trim(); } } /// update the bookmarklet javascript by inserting it into the main wrapper js /// witha replace of "//[[Bookmarklet-Code-Inserted-Here]]" with the bookmarklet javascript bookmarklet.javascript = bookmarkletMainJSWrapper.Replace("//[[Bookmarklet-Code-Inserted-Here]]", bookmarklet.javascript); // add it to the list of bookmarklets. bookmarklets.Add(bookmarklet); } #endregion Load all bookmarklets #region output all bookmarklets into the html output file based on the template. string bookmarkletHtml = ""; string bookmarkletImport = ""; ///Instantiate a minifer instance Minifier minifier = new Microsoft.Ajax.Utilities.Minifier(); foreach (var bookmarklet in bookmarklets) { //bookmarkletHtml += "<a href='javascript:" + HttpUtility.JavaScriptStringEncode(jsMinifer.Compress(kvp.Value)) + "'>" + kvp.Key + "</a>" + Environment.NewLine; bookmarkletHtml += "<p>"; /// append the bookmarklet js minified. Replace all ' with \\' to escape any js quotes. bookmarkletHtml += "<a href=\"javascript:" + minifier.MinifyJavaScript(bookmarklet.javascript, cs).Replace("'", "\\'").Replace("\"", "'") + "\">" + bookmarklet.Name + "</a>" + Environment.NewLine; if (!string.IsNullOrEmpty(bookmarklet.Description)) { bookmarkletHtml += "<br/>"; bookmarkletHtml += bookmarklet.Description; } bookmarkletHtml += "</p>"; /// append the bookmarklet js minified. Replace all ' with \\' to escape any js quotes. bookmarkletImport += "\t\t<DT><A HREF=\"javascript:" + minifier.MinifyJavaScript(bookmarklet.javascript, cs).Replace("'", "\\'").Replace("\"", "'") + "\">" + bookmarklet.Name + "</A>" + Environment.NewLine; } string html = htmlTemplate.Replace("<!--Bookmarklets-->", bookmarkletHtml); /// write the results to the html output file File.WriteAllText(Properties.Settings.Default.BookmarkletHtmlOutput, html); html = importableTemplate.Replace("<!--Bookmarklets-->", bookmarkletImport); /// write the results to the html output file File.WriteAllText(Properties.Settings.Default.BookmarkletImportOutput, html); #endregion output all bookmarklets into the html output file based on the template. }