Used to render embeded resources

Assets

    public class Assets
    {
        private static IBundleResolver resolver;
        internal static IBundleResolver Resolver
        {
            get { return resolver ?? BundleResolver.Current; }
            set { resolver = value; }
        }

        private static IHtmlString RenderTag(string template, params string[] attributes)
        {
            var list = DeterminePathsToRender(attributes);
            var builder = new StringBuilder();

            foreach (var path in list)
            {
                builder.AppendLine(string.Format(template, HttpUtility.UrlPathEncode(path)));
            }

            return new HtmlString(builder.ToString());            
        }

        public static IHtmlString RenderScripts(params string[] attributes)
        {
            return RenderTag("<script src=\"{0}\"></script>", attributes);
        }

        public static IHtmlString RenderStyles(params string[] attributes)
        {
            return RenderTag("<link href=\"{0}\" rel=\"stylesheet\"/>", attributes);
        }

        private static IEnumerable<string> DeterminePathsToRender(IEnumerable<string> assets)
        {
            var list = new List<string>();
            foreach (var asset in assets)
            {
                if (Resolver.IsBundleVirtualPath(asset))
                {
                    if (BundleTable.EnableOptimizations)
                        list.Add(ResolveVirtualPath(asset));
                    else
                        list.AddRange(GetBundleContents(asset).Select(ResolveVirtualPath));
                }
                else
                {
                    list.Add(ResolveVirtualPath(asset));
                }
            }

            return EliminateDuplicatesAndResolveUrls(list);
        }

        private static string ResolveVirtualPath(string virtualPath)
        {
            return UrlHelper.GenerateContentUrl(virtualPath, new HttpContextWrapper(HttpContext.Current));
        }

        private static IEnumerable<string> GetBundleContents(string virtualPath)
        {
            var bundle = BundleTable.Bundles.GetBundleFor(virtualPath) as EmbededResourceBundle;
            return bundle == null ? null : bundle.GetItems();
        }

        private static IEnumerable<string> EliminateDuplicatesAndResolveUrls(IEnumerable<string> paths)
        {
            var list1 = new List<string>();
            var hashSet1 = new HashSet<string>();
            var hashSet2 = new HashSet<string>();
            foreach (var virtualPath1 in paths.Where(virtualPath1 => !hashSet1.Contains(virtualPath1)))
            {
                if (Resolver.IsBundleVirtualPath(virtualPath1))
                {
                    foreach (var virtualPath2 in Resolver.GetBundleContents(virtualPath1))
                        hashSet2.Add(virtualPath2);
                    list1.Add(Resolver.GetBundleUrl(virtualPath1));
                }
                else
                {
                    var str = virtualPath1;
                    if (!hashSet1.Contains(str))
                    {
                        hashSet1.Add(str);
                        list1.Add(str);
                    }
                }
                hashSet1.Add(virtualPath1);
            }

            return list1.Where(str => !hashSet2.Contains(str)).ToList();
        }
    }