diff --git a/src/Orchard.Tests.Modules/Conditions/ConditionEvaluationTests.cs b/src/Orchard.Tests.Modules/Conditions/ConditionEvaluationTests.cs new file mode 100644 index 000000000..76ececaea --- /dev/null +++ b/src/Orchard.Tests.Modules/Conditions/ConditionEvaluationTests.cs @@ -0,0 +1,57 @@ +using System; +using Autofac; +using NUnit.Framework; +using Orchard.Caching; +using Orchard.Conditions.Services; +using Orchard.Scripting; +using Orchard.Tests.Stubs; + +namespace Orchard.Tests.Modules.Conditions { + [TestFixture] + public class ConditionEvaluationTests { + private IContainer _container; + private IConditionManager _conditionManager; + + [SetUp] + public void Init() { + var builder = new ContainerBuilder(); + builder.RegisterType().As(); + builder.RegisterType().As(); + builder.RegisterType().As(); + builder.RegisterType().As(); + + _container = builder.Build(); + _conditionManager = _container.Resolve(); + } + + [Test] + public void ProviderGetsCalledForExpression() { + var result = _conditionManager.Matches("hello"); + Assert.IsTrue(result); + } + + [Test] + public void RubyExpressionIsEvaluated() { + var result = _conditionManager.Matches("not hello"); + Assert.IsFalse(result); + } + + [Test] + public void ArgumentsArePassedCorrectly() { + var result = _conditionManager.Matches("add(2, 3) == 5"); + Assert.IsTrue(result); + } + } + + public class AlwaysTrueCondition : IConditionProvider { + public void Evaluate(ConditionEvaluationContext evaluationContext) { + if (evaluationContext.FunctionName == "add") { + evaluationContext.Result = Convert.ToInt32(evaluationContext.Arguments[0]) + Convert.ToInt32(evaluationContext.Arguments[1]); + return; + } + + evaluationContext.Result = true; + } + } +} + diff --git a/src/Orchard.Tests.Modules/Widgets/RuleEngine/UrlRuleProviderTest.cs b/src/Orchard.Tests.Modules/Conditions/Providers/UrlRuleConditionTest.cs similarity index 62% rename from src/Orchard.Tests.Modules/Widgets/RuleEngine/UrlRuleProviderTest.cs rename to src/Orchard.Tests.Modules/Conditions/Providers/UrlRuleConditionTest.cs index f70dd00b6..f77b7e790 100644 --- a/src/Orchard.Tests.Modules/Widgets/RuleEngine/UrlRuleProviderTest.cs +++ b/src/Orchard.Tests.Modules/Conditions/Providers/UrlRuleConditionTest.cs @@ -1,87 +1,87 @@ -using System; -using Autofac; -using NUnit.Framework; -using Orchard.Environment.Configuration; -using Orchard.Mvc; -using Orchard.Tests.Stubs; -using Orchard.Widgets.RuleEngine; -using Orchard.Widgets.Services; - -namespace Orchard.Tests.Modules.Widgets.RuleEngine { - [TestFixture] - public class UrlRuleProviderTest { - private IContainer _container; - private IRuleProvider _urlRuleProvider; - private StubHttpContextAccessor _stubContextAccessor; - private ShellSettings _shellSettings; - - [SetUp] - public void Init() { - var builder = new ContainerBuilder(); - _shellSettings = new ShellSettings { RequestUrlPrefix = String.Empty }; - builder.RegisterType().As(); - builder.RegisterInstance(_shellSettings); - _stubContextAccessor = new StubHttpContextAccessor(); - builder.RegisterInstance(_stubContextAccessor).As(); - _container = builder.Build(); - _urlRuleProvider = _container.Resolve(); - } - - [Test] - public void UrlForHomePageMatchesHomePagePath() { - _stubContextAccessor.Set(new StubHttpContext("~/")); - var context = new RuleContext { FunctionName = "url", Arguments = new[] { "~/" } }; - _urlRuleProvider.Process(context); - Assert.That(context.Result, Is.True); - } - - [Test] - public void UrlForAboutPageMatchesAboutPagePath() { - _stubContextAccessor.Set(new StubHttpContext("~/about")); - var context = new RuleContext { FunctionName = "url", Arguments = new[] { "~/about" } }; - _urlRuleProvider.Process(context); - Assert.That(context.Result, Is.True); - } - - [Test] - public void UrlForBlogWithEndingWildcardMatchesBlogPostPageInSaidBlog() { - _stubContextAccessor.Set(new StubHttpContext("~/my-blog/my-blog-post")); - var context = new RuleContext { FunctionName = "url", Arguments = new[] { "~/my-blog/*" } }; - _urlRuleProvider.Process(context); - Assert.That(context.Result, Is.True); - } - - [Test] - public void UrlForHomePageDoesNotMatchAboutPagePath() { - _stubContextAccessor.Set(new StubHttpContext("~/about")); - var context = new RuleContext { FunctionName = "url", Arguments = new[] { "~/" } }; - _urlRuleProvider.Process(context); - Assert.That(context.Result, Is.False); - } - - [Test] - public void UrlForAboutPageMatchesDifferentCasedAboutPagePath() { - _stubContextAccessor.Set(new StubHttpContext("~/About")); - var context = new RuleContext { FunctionName = "url", Arguments = new[] { "~/about" } }; - _urlRuleProvider.Process(context); - Assert.That(context.Result, Is.True); - } - - [Test] - public void UrlForAboutPageWithEndingSlashMatchesAboutPagePath() { - _stubContextAccessor.Set(new StubHttpContext("~/About/")); - var context = new RuleContext { FunctionName = "url", Arguments = new[] { "~/about" } }; - _urlRuleProvider.Process(context); - Assert.That(context.Result, Is.True); - } - - [Test] - public void UrlForHomePageMatchesHomePagePathWithUrlPrefix() { - _stubContextAccessor.Set(new StubHttpContext("~/site1")); - _shellSettings.RequestUrlPrefix = "site1"; - var context = new RuleContext { FunctionName = "url", Arguments = new[] { "~/" } }; - _urlRuleProvider.Process(context); - Assert.That(context.Result, Is.True); - } - } +using System; +using Autofac; +using NUnit.Framework; +using Orchard.Conditions.Services; +using Orchard.Environment.Configuration; +using Orchard.Mvc; +using Orchard.Tests.Stubs; +using Orchard.Widgets.RuleEngine; + +namespace Orchard.Tests.Modules.Conditions.Providers { + [TestFixture] + public class UrlRuleConditionTest { + private IContainer _container; + private IConditionProvider _urlCondition; + private StubHttpContextAccessor _stubContextAccessor; + private ShellSettings _shellSettings; + + [SetUp] + public void Init() { + var builder = new ContainerBuilder(); + _shellSettings = new ShellSettings { RequestUrlPrefix = String.Empty }; + builder.RegisterType().As(); + builder.RegisterInstance(_shellSettings); + _stubContextAccessor = new StubHttpContextAccessor(); + builder.RegisterInstance(_stubContextAccessor).As(); + _container = builder.Build(); + _urlCondition = _container.Resolve(); + } + + [Test] + public void UrlForHomePageMatchesHomePagePath() { + _stubContextAccessor.Set(new StubHttpContext("~/")); + var context = new ConditionEvaluationContext { FunctionName = "url", Arguments = new[] { "~/" } }; + _urlCondition.Evaluate(context); + Assert.That(context.Result, Is.True); + } + + [Test] + public void UrlForAboutPageMatchesAboutPagePath() { + _stubContextAccessor.Set(new StubHttpContext("~/about")); + var context = new ConditionEvaluationContext { FunctionName = "url", Arguments = new[] { "~/about" } }; + _urlCondition.Evaluate(context); + Assert.That(context.Result, Is.True); + } + + [Test] + public void UrlForBlogWithEndingWildcardMatchesBlogPostPageInSaidBlog() { + _stubContextAccessor.Set(new StubHttpContext("~/my-blog/my-blog-post")); + var context = new ConditionEvaluationContext { FunctionName = "url", Arguments = new[] { "~/my-blog/*" } }; + _urlCondition.Evaluate(context); + Assert.That(context.Result, Is.True); + } + + [Test] + public void UrlForHomePageDoesNotMatchAboutPagePath() { + _stubContextAccessor.Set(new StubHttpContext("~/about")); + var context = new ConditionEvaluationContext { FunctionName = "url", Arguments = new[] { "~/" } }; + _urlCondition.Evaluate(context); + Assert.That(context.Result, Is.False); + } + + [Test] + public void UrlForAboutPageMatchesDifferentCasedAboutPagePath() { + _stubContextAccessor.Set(new StubHttpContext("~/About")); + var context = new ConditionEvaluationContext { FunctionName = "url", Arguments = new[] { "~/about" } }; + _urlCondition.Evaluate(context); + Assert.That(context.Result, Is.True); + } + + [Test] + public void UrlForAboutPageWithEndingSlashMatchesAboutPagePath() { + _stubContextAccessor.Set(new StubHttpContext("~/About/")); + var context = new ConditionEvaluationContext { FunctionName = "url", Arguments = new[] { "~/about" } }; + _urlCondition.Evaluate(context); + Assert.That(context.Result, Is.True); + } + + [Test] + public void UrlForHomePageMatchesHomePagePathWithUrlPrefix() { + _stubContextAccessor.Set(new StubHttpContext("~/site1")); + _shellSettings.RequestUrlPrefix = "site1"; + var context = new ConditionEvaluationContext { FunctionName = "url", Arguments = new[] { "~/" } }; + _urlCondition.Evaluate(context); + Assert.That(context.Result, Is.True); + } + } } \ No newline at end of file diff --git a/src/Orchard.Tests.Modules/Orchard.Tests.Modules.csproj b/src/Orchard.Tests.Modules/Orchard.Tests.Modules.csproj index 103e102d1..3c30725bd 100644 --- a/src/Orchard.Tests.Modules/Orchard.Tests.Modules.csproj +++ b/src/Orchard.Tests.Modules/Orchard.Tests.Modules.csproj @@ -190,9 +190,9 @@ - + - + @@ -225,6 +225,10 @@ {14C049FD-B35B-415A-A824-87F26B26E7FD} Orchard.Comments + + {98251eae-a41b-47b2-aa91-e28b8482da70} + Orchard.Conditions + {4A4595EF-6C37-4F99-96ED-4AE0B9E438D3} Orchard.DesignerTools diff --git a/src/Orchard.Tests.Modules/Widgets/WidgetsTests.cs b/src/Orchard.Tests.Modules/Widgets/WidgetsTests.cs deleted file mode 100644 index 4b34a09df..000000000 --- a/src/Orchard.Tests.Modules/Widgets/WidgetsTests.cs +++ /dev/null @@ -1,58 +0,0 @@ -using System; -using Autofac; -using NUnit.Framework; -using Orchard.Scripting; -using Orchard.Caching; -using Orchard.Tests.Stubs; -using Orchard.Widgets.RuleEngine; -using Orchard.Widgets.Services; - -namespace Orchard.Tests.Modules.Widgets { - [TestFixture] - public class WidgetsTests { - private IContainer _container; - private IRuleManager _ruleManager; - - [SetUp] - public void Init() { - var builder = new ContainerBuilder(); - builder.RegisterType().As(); - builder.RegisterType().As(); - builder.RegisterType().As(); - builder.RegisterType().As(); - - _container = builder.Build(); - _ruleManager = _container.Resolve(); - } - - [Test] - public void ProviderGetsCalledForExpression() { - bool result = _ruleManager.Matches("hello"); - Assert.IsTrue(result); - } - - [Test] - public void RubyExpressionIsEvaluated() { - bool result = _ruleManager.Matches("not hello"); - Assert.IsFalse(result); - } - - [Test] - public void ArgumentsArePassedCorrectly() { - bool result = _ruleManager.Matches("add(2, 3) == 5"); - Assert.IsTrue(result); - } - } - - public class AlwaysTrueRuleProvider : IRuleProvider { - public void Process(RuleContext ruleContext) { - if (ruleContext.FunctionName == "add") { - ruleContext.Result = Convert.ToInt32(ruleContext.Arguments[0]) + Convert.ToInt32(ruleContext.Arguments[1]); - return; - } - - ruleContext.Result = true; - } - } -} - diff --git a/src/Orchard.Web/Modules/Orchard.AuditTrail/Services/DiffGramAnalyzer.cs b/src/Orchard.Web/Modules/Orchard.AuditTrail/Services/DiffGramAnalyzer.cs index 42c51c62e..d9e4ad708 100644 --- a/src/Orchard.Web/Modules/Orchard.AuditTrail/Services/DiffGramAnalyzer.cs +++ b/src/Orchard.Web/Modules/Orchard.AuditTrail/Services/DiffGramAnalyzer.cs @@ -66,7 +66,6 @@ namespace Orchard.AuditTrail.Services { var originalContent = currentElement.Value; var currentContent = reader.ReadElementContentAsString(); - stack.Pop(); readNext = false; yield return new DiffNode { diff --git a/src/Orchard.Web/Modules/Orchard.Conditions/Module.txt b/src/Orchard.Web/Modules/Orchard.Conditions/Module.txt new file mode 100644 index 000000000..2c60ad94a --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Conditions/Module.txt @@ -0,0 +1,13 @@ +Name: Conditions +AntiForgery: enabled +Author: The Orchard Team +Website: http://orchardproject.net +Version: 1.0 +OrchardVersion: 1.9 +Description: Provides a rules API that evaluate to true or false. +Features: + Orchard.Conditions: + Name: Conditions + Description: Provides a rules API that evaluate to true or false. + Category: Scripting + Dependencies: Orchard.Scripting \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Conditions/Orchard.Conditions.csproj b/src/Orchard.Web/Modules/Orchard.Conditions/Orchard.Conditions.csproj new file mode 100644 index 000000000..a243ac54b --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Conditions/Orchard.Conditions.csproj @@ -0,0 +1,144 @@ + + + + + Debug + AnyCPU + 9.0.30729 + 2.0 + {98251EAE-A41B-47B2-AA91-E28B8482DA70} + {349c5851-65df-11da-9384-00065b846f21};{fae04ec0-301f-11d3-bf4b-00c04f79efbc} + Library + Properties + Orchard.Conditions + Orchard.Conditions + v4.5.1 + false + + + 4.0 + + + false + + + + + + + + true + full + false + bin\ + DEBUG;TRACE + prompt + 4 + ..\..\..\OrchardBasicCorrectness.ruleset + false + + + pdbonly + true + bin\ + TRACE + prompt + 4 + AllRules.ruleset + false + + + + + + + 3.5 + + + + False + ..\..\..\..\lib\aspnetmvc\System.Web.Mvc.dll + + + + + + + + + + + + + + + + + {2D1D92BB-4555-4CBE-8D0E-63563D6CE4C6} + Orchard.Framework + false + + + {9916839C-39FC-4CEB-A5AF-89CA7E87119F} + Orchard.Core + false + + + {99002b65-86f7-415e-bf4a-381aa8ab9ccc} + Orchard.Scripting + + + + + + + + + + + + + 10.0 + $(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion) + + + + + + + + $(ProjectDir)\..\Manifests + + + + + + + + + + + + False + True + 45979 + / + + + False + True + http://orchard.codeplex.com + False + + + + + \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Conditions/Properties/AssemblyInfo.cs b/src/Orchard.Web/Modules/Orchard.Conditions/Properties/AssemblyInfo.cs new file mode 100644 index 000000000..fb44458d9 --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Conditions/Properties/AssemblyInfo.cs @@ -0,0 +1,37 @@ +using System.Reflection; +using System.Runtime.CompilerServices; +using System.Runtime.InteropServices; +using System.Security; + +// General Information about an assembly is controlled through the following +// set of attributes. Change these attribute values to modify the information +// associated with an assembly. +[assembly: AssemblyTitle("Orchard.Conditions")] +[assembly: AssemblyDescription("")] +[assembly: AssemblyConfiguration("")] +[assembly: AssemblyProduct("Orchard")] +[assembly: AssemblyCopyright("")] +[assembly: AssemblyTrademark("")] +[assembly: AssemblyCulture("")] + +// Setting ComVisible to false makes the types in this assembly not visible +// to COM components. If you need to access a type in this assembly from +// COM, set the ComVisible attribute to true on that type. +[assembly: ComVisible(false)] + +// The following GUID is for the ID of the typelib if this project is exposed to COM +[assembly: Guid("1c288740-10c0-4fa9-a051-501d259e4fc0")] + +// Version information for an assembly consists of the following four values: +// +// Major Version +// Minor Version +// Build Number +// Revision +// +// You can specify all the values or you can default the Revision and Build Numbers +// by using the '*' as shown below: + +[assembly: AssemblyVersion("1.0.0.0")] +[assembly: AssemblyFileVersion("1.0.0.0")] + diff --git a/src/Orchard.Web/Modules/Orchard.Conditions/Providers/AuthenticatedCondition.cs b/src/Orchard.Web/Modules/Orchard.Conditions/Providers/AuthenticatedCondition.cs new file mode 100644 index 000000000..cfbc6d4a4 --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Conditions/Providers/AuthenticatedCondition.cs @@ -0,0 +1,26 @@ +using System; +using Orchard.Conditions.Services; +using Orchard.Security; + +namespace Orchard.Conditions.Providers { + public class AuthenticatedCondition : IConditionProvider { + private readonly IAuthenticationService _authenticationService; + + public AuthenticatedCondition(IAuthenticationService authenticationService) { + _authenticationService = authenticationService; + } + + public void Evaluate(ConditionEvaluationContext evaluationContext) { + if (!String.Equals(evaluationContext.FunctionName, "authenticated", StringComparison.OrdinalIgnoreCase)) { + return; + } + + if (_authenticationService.GetAuthenticatedUser() != null) { + evaluationContext.Result = true; + return; + } + + evaluationContext.Result = false; + } + } +} \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Conditions/Providers/BuiltinCondition.cs b/src/Orchard.Web/Modules/Orchard.Conditions/Providers/BuiltinCondition.cs new file mode 100644 index 000000000..5d8436652 --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Conditions/Providers/BuiltinCondition.cs @@ -0,0 +1,18 @@ +using System; +using Orchard.Conditions.Services; + +namespace Orchard.Conditions.Providers { + public class BuiltinCondition : IConditionProvider { + private readonly IWorkContextAccessor _workContextAccessor; + + public BuiltinCondition(IWorkContextAccessor workContextAccessor) { + _workContextAccessor = workContextAccessor; + } + + public void Evaluate(ConditionEvaluationContext evaluationContext) { + if (string.Equals(evaluationContext.FunctionName, "WorkContext", StringComparison.OrdinalIgnoreCase)) { + evaluationContext.Result = _workContextAccessor.GetContext(); + } + } + } +} \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Widgets/RuleEngine/UrlRuleProvider.cs b/src/Orchard.Web/Modules/Orchard.Conditions/Providers/UrlCondition.cs similarity index 72% rename from src/Orchard.Web/Modules/Orchard.Widgets/RuleEngine/UrlRuleProvider.cs rename to src/Orchard.Web/Modules/Orchard.Conditions/Providers/UrlCondition.cs index 76a6cec48..e861fc3f2 100644 --- a/src/Orchard.Web/Modules/Orchard.Widgets/RuleEngine/UrlRuleProvider.cs +++ b/src/Orchard.Web/Modules/Orchard.Conditions/Providers/UrlCondition.cs @@ -1,47 +1,47 @@ -using System; -using System.Web; -using Orchard.Environment.Configuration; -using Orchard.Mvc; -using Orchard.Widgets.Services; - -namespace Orchard.Widgets.RuleEngine { - public class UrlRuleProvider : IRuleProvider { - private readonly IHttpContextAccessor _httpContextAccessor; - private readonly ShellSettings _shellSettings; - - public UrlRuleProvider(IHttpContextAccessor httpContextAccessor, ShellSettings shellSettings) { - _httpContextAccessor = httpContextAccessor; - _shellSettings = shellSettings; - } - - public void Process(RuleContext ruleContext) { - if (!String.Equals(ruleContext.FunctionName, "url", StringComparison.OrdinalIgnoreCase)) - return; - - var context = _httpContextAccessor.Current(); - var url = Convert.ToString(ruleContext.Arguments[0]); - if (url.StartsWith("~/")) { - url = url.Substring(2); - var appPath = context.Request.ApplicationPath; - if (appPath == "/") - appPath = ""; - - if(!String.IsNullOrEmpty(_shellSettings.RequestUrlPrefix)) - appPath = String.Concat(appPath, "/", _shellSettings.RequestUrlPrefix); - - url = String.Concat(appPath, "/", url); - } - - if (!url.Contains("?")) - url = url.TrimEnd('/'); - - var requestPath = context.Request.Path; - if (!requestPath.Contains("?")) - requestPath = requestPath.TrimEnd('/'); - - ruleContext.Result = url.EndsWith("*") - ? requestPath.StartsWith(url.TrimEnd('*'), StringComparison.OrdinalIgnoreCase) - : string.Equals(requestPath, url, StringComparison.OrdinalIgnoreCase); - } - } +using System; +using System.Web; +using Orchard.Conditions.Services; +using Orchard.Environment.Configuration; +using Orchard.Mvc; + +namespace Orchard.Widgets.RuleEngine { + public class UrlCondition : IConditionProvider { + private readonly IHttpContextAccessor _httpContextAccessor; + private readonly ShellSettings _shellSettings; + + public UrlCondition(IHttpContextAccessor httpContextAccessor, ShellSettings shellSettings) { + _httpContextAccessor = httpContextAccessor; + _shellSettings = shellSettings; + } + + public void Evaluate(ConditionEvaluationContext evaluationContext) { + if (!String.Equals(evaluationContext.FunctionName, "url", StringComparison.OrdinalIgnoreCase)) + return; + + var context = _httpContextAccessor.Current(); + var url = Convert.ToString(evaluationContext.Arguments[0]); + if (url.StartsWith("~/")) { + url = url.Substring(2); + var appPath = context.Request.ApplicationPath; + if (appPath == "/") + appPath = ""; + + if(!String.IsNullOrEmpty(_shellSettings.RequestUrlPrefix)) + appPath = String.Concat(appPath, "/", _shellSettings.RequestUrlPrefix); + + url = String.Concat(appPath, "/", url); + } + + if (!url.Contains("?")) + url = url.TrimEnd('/'); + + var requestPath = context.Request.Path; + if (!requestPath.Contains("?")) + requestPath = requestPath.TrimEnd('/'); + + evaluationContext.Result = url.EndsWith("*") + ? requestPath.StartsWith(url.TrimEnd('*'), StringComparison.OrdinalIgnoreCase) + : string.Equals(requestPath, url, StringComparison.OrdinalIgnoreCase); + } + } } \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Conditions/Services/ConditionEvaluationContext.cs b/src/Orchard.Web/Modules/Orchard.Conditions/Services/ConditionEvaluationContext.cs new file mode 100644 index 000000000..fb69855a8 --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Conditions/Services/ConditionEvaluationContext.cs @@ -0,0 +1,7 @@ +namespace Orchard.Conditions.Services { + public class ConditionEvaluationContext { + public string FunctionName { get; set; } + public object[] Arguments { get; set; } + public object Result { get; set; } + } +} \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Conditions/Services/ConditionManager.cs b/src/Orchard.Web/Modules/Orchard.Conditions/Services/ConditionManager.cs new file mode 100644 index 000000000..e0738d238 --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Conditions/Services/ConditionManager.cs @@ -0,0 +1,52 @@ +using System.Collections.Generic; +using System.Linq; +using Orchard.Localization; +using Orchard.Scripting; + +namespace Orchard.Conditions.Services { + public class ConditionManager : IConditionManager { + private readonly IConditionProvider _conditions; + private readonly IEnumerable _evaluators; + + public ConditionManager(IConditionProvider conditions, IEnumerable evaluators) { + _conditions = conditions; + _evaluators = evaluators; + T = NullLocalizer.Instance; + } + + public Localizer T { get; set; } + + public bool Matches(string expression) { + var evaluator = _evaluators.FirstOrDefault(); + if (evaluator == null) { + throw new OrchardException(T("There are currently no scripting engines enabled")); + } + + var result = evaluator.Evaluate(expression, new List { new GlobalMethodProvider(this) }); + if (!(result is bool)) { + throw new OrchardException(T("Expression is not a boolean value")); + } + return (bool)result; + } + + private class GlobalMethodProvider : IGlobalMethodProvider { + private readonly ConditionManager _conditionManager; + + public GlobalMethodProvider(ConditionManager conditionManager) { + _conditionManager = conditionManager; + } + + public void Process(GlobalMethodContext context) { + var ruleContext = new ConditionEvaluationContext { + FunctionName = context.FunctionName, + Arguments = context.Arguments.ToArray(), + Result = context.Result + }; + + _conditionManager._conditions.Evaluate(ruleContext); + + context.Result = ruleContext.Result; + } + } + } +} \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Conditions/Services/IConditionManager.cs b/src/Orchard.Web/Modules/Orchard.Conditions/Services/IConditionManager.cs new file mode 100644 index 000000000..5d2482f46 --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Conditions/Services/IConditionManager.cs @@ -0,0 +1,5 @@ +namespace Orchard.Conditions.Services { + public interface IConditionManager : IDependency { + bool Matches(string expression); + } +} \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Conditions/Services/IConditionProvider.cs b/src/Orchard.Web/Modules/Orchard.Conditions/Services/IConditionProvider.cs new file mode 100644 index 000000000..01e27fa3b --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Conditions/Services/IConditionProvider.cs @@ -0,0 +1,7 @@ +using Orchard.Events; + +namespace Orchard.Conditions.Services { + public interface IConditionProvider : IEventHandler { + void Evaluate(ConditionEvaluationContext evaluationContext); + } +} \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Conditions/Web.config b/src/Orchard.Web/Modules/Orchard.Conditions/Web.config new file mode 100644 index 000000000..82da01f41 --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Conditions/Web.config @@ -0,0 +1,43 @@ + + + + + + + +
+
+ + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + + diff --git a/src/Orchard.Web/Modules/Orchard.DynamicForms/Handlers/ClientValidationRegistrationCoordinator.cs b/src/Orchard.Web/Modules/Orchard.DynamicForms/Handlers/ClientValidationRegistrationCoordinator.cs index 3f874b676..7cc14e7d1 100644 --- a/src/Orchard.Web/Modules/Orchard.DynamicForms/Handlers/ClientValidationRegistrationCoordinator.cs +++ b/src/Orchard.Web/Modules/Orchard.DynamicForms/Handlers/ClientValidationRegistrationCoordinator.cs @@ -1,9 +1,11 @@ +using System; using System.Linq; using Orchard.DynamicForms.Elements; using Orchard.DynamicForms.Services; using Orchard.DynamicForms.Services.Models; using Orchard.Layouts.Framework.Display; using Orchard.Layouts.Framework.Drivers; +using Orchard.Layouts.Framework.Elements; using Orchard.Layouts.Services; namespace Orchard.DynamicForms.Handlers { @@ -46,11 +48,18 @@ namespace Orchard.DynamicForms.Handlers { } void IElementEventHandler.CreatingDisplay(ElementCreatingDisplayShapeContext context) { } - void IElementEventHandler.Displayed(ElementDisplayedContext context) {} + void IElementEventHandler.Displayed(ElementDisplayedContext context) { } void IFormElementEventHandler.GetElementValue(FormElement element, ReadElementValuesContext context) { } - void IElementEventHandler.Creating(ElementCreatingContext context) {} - void IElementEventHandler.Created(ElementCreatedContext context) {} - void IElementEventHandler.BuildEditor(ElementEditorContext context) {} - void IElementEventHandler.UpdateEditor(ElementEditorContext context) {} + void IElementEventHandler.Creating(ElementCreatingContext context) { } + void IElementEventHandler.Created(ElementCreatedContext context) { } + void IElementEventHandler.BuildEditor(ElementEditorContext context) { } + void IElementEventHandler.UpdateEditor(ElementEditorContext context) { } + void IElementEventHandler.Removing(ElementRemovingContext context) { } + void IElementEventHandler.LayoutSaving(ElementSavingContext context) { } + void IElementEventHandler.Exporting(ExportElementContext context) { } + void IElementEventHandler.Exported(ExportElementContext context) { } + void IElementEventHandler.Importing(ImportElementContext context) { } + void IElementEventHandler.Imported(ImportElementContext context) { } + void IElementEventHandler.ImportCompleted(ImportElementContext context) { } } } \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Assets.json b/src/Orchard.Web/Modules/Orchard.Layouts/Assets.json index 6a7f2175c..9aab5a7cc 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Assets.json +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Assets.json @@ -53,6 +53,7 @@ "inputs": [ "Assets/JavaScript/Models/Helpers.js", "Assets/JavaScript/Models/Editor.js", + "Assets/JavaScript/Models/RecycleBin.js", "Assets/JavaScript/Models/Element.js", "Assets/JavaScript/Models/Container.js", "Assets/JavaScript/Models/Canvas.js", diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/Models/Container.js b/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/Models/Container.js index 336b73b6e..1825ba5f0 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/Models/Container.js +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/Models/Container.js @@ -46,6 +46,7 @@ var index = _(this.children).indexOf(child); if (index >= 0) { this.children.splice(index, 1); + this.editor.recycleBin.add(child); if (child.getIsActive()) this.editor.activeElement = null; if (child.getIsFocused()) { diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/Models/Editor.js b/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/Models/Editor.js index 86b664804..30cdb4916 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/Models/Editor.js +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/Models/Editor.js @@ -10,6 +10,7 @@ this.dropTargetElement = null; this.isDragging = false; this.isResizing = false; + this.recycleBin = new LayoutEditor.RecycleBin(); this.resetToolboxElements = function () { this.toolboxElements = [ diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/Models/RecycleBin.js b/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/Models/RecycleBin.js new file mode 100644 index 000000000..c5318455c --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Assets/JavaScript/Models/RecycleBin.js @@ -0,0 +1,27 @@ +var LayoutEditor; +(function (LayoutEditor) { + + LayoutEditor.RecycleBin = function () { + this.elements = []; + + this.add = function(element) { + this.elements.push(element); + }; + + this.toObject = function () { + var result = { + type: "RecycleBin", + children: [] + }; + + for (var i = 0; i < this.elements.length; i++) { + var element = this.elements[i]; + var dto = element.toObject(); + result.children.push(dto); + } + + return result; + }; + }; + +})(LayoutEditor || (LayoutEditor = {})); diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Drivers/LayoutPartDriver.cs b/src/Orchard.Web/Modules/Orchard.Layouts/Drivers/LayoutPartDriver.cs index 5d827a037..61b0cd668 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Drivers/LayoutPartDriver.cs +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Drivers/LayoutPartDriver.cs @@ -5,6 +5,7 @@ using Orchard.ContentManagement; using Orchard.ContentManagement.Drivers; using Orchard.ContentManagement.Handlers; using Orchard.DisplayManagement; +using Orchard.Layouts.Elements; using Orchard.Layouts.Framework.Display; using Orchard.Layouts.Framework.Drivers; using Orchard.Layouts.Framework.Elements; @@ -112,12 +113,12 @@ namespace Orchard.Layouts.Drivers { updater.TryUpdateModel(viewModel, Prefix, null, new[] { "Part", "Templates" }); var describeContext = new DescribeElementsContext { Content = part }; var elementInstances = _mapper.ToLayoutModel(viewModel.LayoutEditor.Data, describeContext).ToArray(); - var removedElementInstances = _serializer.Deserialize(viewModel.LayoutEditor.Trash, describeContext).ToArray(); + var recycleBin = (RecycleBin)_mapper.ToLayoutModel(viewModel.LayoutEditor.RecycleBin, describeContext).SingleOrDefault(); var context = new LayoutSavingContext { Content = part, Updater = updater, Elements = elementInstances, - RemovedElements = removedElementInstances + RemovedElements = recycleBin != null ? recycleBin.Elements : Enumerable.Empty() }; _elementManager.Saving(context); diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Elements/PlaceableContentItem.cs b/src/Orchard.Web/Modules/Orchard.Layouts/Elements/PlaceableContentItem.cs new file mode 100644 index 000000000..441ed697e --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Elements/PlaceableContentItem.cs @@ -0,0 +1,23 @@ +using Orchard.Layouts.Framework.Elements; +using Orchard.Layouts.Helpers; + +namespace Orchard.Layouts.Elements { + public class PlaceableContentItem : Element { + public override string Category { + get { return "Content Items"; } + } + + public override bool IsSystemElement { + get { return true; } + } + + public override bool HasEditor { + get { return false; } + } + + public int? ContentItemId { + get { return this.Retrieve(x => x.ContentItemId); } + set { this.Store(x => x.ContentItemId, value); } + } + } +} \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Elements/RecycleBin.cs b/src/Orchard.Web/Modules/Orchard.Layouts/Elements/RecycleBin.cs new file mode 100644 index 000000000..10b509e2d --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Elements/RecycleBin.cs @@ -0,0 +1,8 @@ +using Orchard.Layouts.Framework.Elements; + +namespace Orchard.Layouts.Elements { + public class RecycleBin : Container { + public override string Category { get { return null; } } + public override bool IsSystemElement { get { return true; } } + } +} \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Framework/Drivers/ExportElementContext.cs b/src/Orchard.Web/Modules/Orchard.Layouts/Framework/Drivers/ExportElementContext.cs index c00032302..be60f48e1 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Framework/Drivers/ExportElementContext.cs +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Framework/Drivers/ExportElementContext.cs @@ -3,12 +3,14 @@ using Orchard.Layouts.Models; namespace Orchard.Layouts.Framework.Drivers { public class ExportElementContext { - public ExportElementContext() { - ExportableData = new ElementDataDictionary(); + public ExportElementContext(Element element, ILayoutAspect layout, ElementDataDictionary exportableData) { + Element = element; + Layout = layout; + ExportableData = exportableData; } - public ILayoutAspect Layout { get; set; } - public Element Element { get; set; } - public ElementDataDictionary ExportableData { get; set; } + public ILayoutAspect Layout { get; private set; } + public Element Element { get; private set; } + public ElementDataDictionary ExportableData { get; private set; } } } \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Framework/Drivers/ImportElementContext.cs b/src/Orchard.Web/Modules/Orchard.Layouts/Framework/Drivers/ImportElementContext.cs index 51d5c3146..7b6e7cb24 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Framework/Drivers/ImportElementContext.cs +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Framework/Drivers/ImportElementContext.cs @@ -3,13 +3,16 @@ using Orchard.Layouts.Models; namespace Orchard.Layouts.Framework.Drivers { public class ImportElementContext { - public ImportElementContext() { - ExportableData = new ElementDataDictionary(); + public ImportElementContext(Element element, ILayoutAspect layout, ElementDataDictionary exportableData, IContentImportSession session) { + Element = element; + Layout = layout; + ExportableData = exportableData; + Session = session; } - public ILayoutAspect Layout { get; set; } - public Element Element { get; set; } - public ElementDataDictionary ExportableData { get; set; } - public IContentImportSession Session { get; set; } + public ILayoutAspect Layout { get; private set; } + public Element Element { get; private set; } + public ElementDataDictionary ExportableData { get; private set; } + public IContentImportSession Session { get; private set; } } } \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Framework/Elements/ElementDescriptor.cs b/src/Orchard.Web/Modules/Orchard.Layouts/Framework/Elements/ElementDescriptor.cs index 4de7a1889..dc8b606f6 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Framework/Elements/ElementDescriptor.cs +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Framework/Elements/ElementDescriptor.cs @@ -15,9 +15,16 @@ namespace Orchard.Layouts.Framework.Elements { Category = category; GetDrivers = Enumerable.Empty; CreatingDisplay = context => { }; - Displaying = context => {}; + Displaying = context => { }; Editor = context => { }; UpdateEditor = context => { }; + LayoutSaving = context => { }; + Removing = context => { }; + Exporting = context => { }; + Exported = context => { }; + Importing = context => { }; + Imported = context => { }; + ImportCompleted = context => { }; StateBag = new Dictionary(); } @@ -33,6 +40,13 @@ namespace Orchard.Layouts.Framework.Elements { public Action Displayed { get; set; } public Action Editor { get; set; } public Action UpdateEditor { get; set; } + public Action LayoutSaving { get; set; } + public Action Removing { get; set; } + public Action Exporting { get; set; } + public Action Exported { get; set; } + public Action Importing { get; set; } + public Action Imported { get; set; } + public Action ImportCompleted { get; set; } public bool IsSystemElement { get; set; } public bool EnableEditorDialog { get; set; } public IDictionary StateBag { get; set; } diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Framework/Elements/ElementRemovingContext.cs b/src/Orchard.Web/Modules/Orchard.Layouts/Framework/Elements/ElementRemovingContext.cs index 753971b54..a1c6b61f3 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Framework/Elements/ElementRemovingContext.cs +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Framework/Elements/ElementRemovingContext.cs @@ -1,11 +1,20 @@ -namespace Orchard.Layouts.Framework.Elements { - public class ElementRemovingContext : LayoutSavingContext { - public ElementRemovingContext(LayoutSavingContext stub) { - Content = stub.Content; - RemovedElements = stub.RemovedElements; - Updater = stub.Updater; - Elements = stub.Elements; +using System.Collections.Generic; +using Orchard.ContentManagement; + +namespace Orchard.Layouts.Framework.Elements { + public class ElementRemovingContext { + public ElementRemovingContext(Element element, IEnumerable elements, IEnumerable removedElements, IContent content) { + Element = element; + Elements = elements; + RemovedElements = removedElements; + Content = content; } - public Element Element { get; set; } + + public IContent Content { get; private set; } + // All the other elements on the canvas. + public IEnumerable Elements { get; set; } + // All the other removed elements from the canvas (including the current element). + public IEnumerable RemovedElements { get; set; } + public Element Element { get; private set; } } } \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Framework/Elements/ElementSavingContext.cs b/src/Orchard.Web/Modules/Orchard.Layouts/Framework/Elements/ElementSavingContext.cs index 46e31754f..d8aeeb13c 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Framework/Elements/ElementSavingContext.cs +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Framework/Elements/ElementSavingContext.cs @@ -1,10 +1,11 @@ namespace Orchard.Layouts.Framework.Elements { public class ElementSavingContext : LayoutSavingContext { - public ElementSavingContext(LayoutSavingContext stub) { + public ElementSavingContext(Element element, LayoutSavingContext stub) { + Element = element; Content = stub.Content; Updater = stub.Updater; Elements = stub.Elements; } - public Element Element { get; set; } + public Element Element { get; private set; } } } \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Handlers/ElementDriversCoordinator.cs b/src/Orchard.Web/Modules/Orchard.Layouts/Handlers/ElementDriversCoordinator.cs index 904dd08c7..542f51207 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Handlers/ElementDriversCoordinator.cs +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Handlers/ElementDriversCoordinator.cs @@ -1,5 +1,6 @@ using System; using Orchard.Layouts.Framework.Drivers; +using Orchard.Layouts.Framework.Elements; using Orchard.Layouts.Services; namespace Orchard.Layouts.Handlers { @@ -17,6 +18,34 @@ namespace Orchard.Layouts.Handlers { BuildEditorInternal(context, driver => driver.UpdateEditor(context)); } + public override void LayoutSaving(ElementSavingContext context) { + InvokeDrivers(context.Element, driver => driver.LayoutSaving(context)); + } + + public override void Removing(ElementRemovingContext context) { + InvokeDrivers(context.Element, driver => driver.Removing(context)); + } + + public override void Exporting(ExportElementContext context) { + InvokeDrivers(context.Element, driver => driver.Exporting(context)); + } + + public override void Exported(ExportElementContext context) { + InvokeDrivers(context.Element, driver => driver.Exported(context)); + } + + public override void Importing(ImportElementContext context) { + InvokeDrivers(context.Element, driver => driver.Importing(context)); + } + + public override void Imported(ImportElementContext context) { + InvokeDrivers(context.Element, driver => driver.Imported(context)); + } + + public override void ImportCompleted(ImportElementContext context) { + InvokeDrivers(context.Element, driver => driver.ImportCompleted(context)); + } + private void BuildEditorInternal(ElementEditorContext context, Func action) { var descriptor = context.Element.Descriptor; var drivers = _elementManager.GetDrivers(descriptor); @@ -36,5 +65,10 @@ namespace Orchard.Layouts.Handlers { } } } + + private void InvokeDrivers(Element element, Action action) { + var drivers = _elementManager.GetDrivers(element.Descriptor); + drivers.Invoke(action, Logger); + } } } \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Handlers/ElementRuleCoordinator.cs b/src/Orchard.Web/Modules/Orchard.Layouts/Handlers/ElementRuleCoordinator.cs index 05ace83fd..ad5fd9989 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Handlers/ElementRuleCoordinator.cs +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Handlers/ElementRuleCoordinator.cs @@ -1,16 +1,16 @@ using System; using System.Collections.Generic; +using Orchard.Conditions.Services; using Orchard.Layouts.Framework.Display; using Orchard.Layouts.Services; -using Orchard.Widgets.Services; namespace Orchard.Layouts.Handlers { public class ElementRuleCoordinator : ElementEventHandlerBase { - private readonly IRuleManager _ruleManager; + private readonly IConditionManager _conditionManager; private readonly Dictionary _evaluations = new Dictionary(); - public ElementRuleCoordinator(IRuleManager ruleManager) { - _ruleManager = ruleManager; + public ElementRuleCoordinator(IConditionManager conditionManager) { + _conditionManager = conditionManager; } public override void CreatingDisplay(ElementCreatingDisplayShapeContext context) { @@ -27,7 +27,7 @@ namespace Orchard.Layouts.Handlers { if (_evaluations.ContainsKey(rule)) return _evaluations[rule]; - var result = _ruleManager.Matches(rule); + var result = _conditionManager.Matches(rule); _evaluations[rule] = result; return result; } diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Handlers/LayoutPartHandler.cs b/src/Orchard.Web/Modules/Orchard.Layouts/Handlers/LayoutPartHandler.cs index 0e2c3b37a..a61e5e301 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Handlers/LayoutPartHandler.cs +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Handlers/LayoutPartHandler.cs @@ -1,10 +1,13 @@ using System; +using System.Collections.Generic; +using System.Linq; using Orchard.Alias; using Orchard.Autoroute.Models; using Orchard.ContentManagement; using Orchard.ContentManagement.Handlers; using Orchard.Data; using Orchard.DisplayManagement; +using Orchard.Layouts.Framework.Elements; using Orchard.Layouts.Models; using Orchard.Layouts.Services; using Orchard.Utility.Extensions; @@ -17,13 +20,15 @@ namespace Orchard.Layouts.Handlers { private readonly IShapeDisplay _shapeDisplay; private readonly ILayoutSerializer _serializer; private readonly IAliasService _aliasService; + private readonly IElementManager _elementManager; public LayoutPartHandler( - IRepository repository, - ILayoutManager layoutManager, - IContentManager contentManager, - IContentPartDisplay contentPartDisplay, - IShapeDisplay shapeDisplay, + IRepository repository, + ILayoutManager layoutManager, + IElementManager elementManager, + IContentManager contentManager, + IContentPartDisplay contentPartDisplay, + IShapeDisplay shapeDisplay, ILayoutSerializer serializer, IAliasService aliasService) { @@ -33,10 +38,12 @@ namespace Orchard.Layouts.Handlers { _shapeDisplay = shapeDisplay; _serializer = serializer; _aliasService = aliasService; + _elementManager = elementManager; Filters.Add(StorageFilter.For(repository)); OnPublished(UpdateTemplateClients); OnIndexing(IndexLayout); + OnRemoved(RemoveElements); } private void IndexLayout(IndexContentContext context, LayoutPart part) { @@ -87,6 +94,16 @@ namespace Orchard.Layouts.Handlers { } } + private void RemoveElements(RemoveContentContext context, LayoutPart part) { + var elements = _layoutManager.LoadElements(part).ToList(); + var savingContext = new LayoutSavingContext { + Content = part, + Elements = new List(), + RemovedElements = elements + }; + _elementManager.Removing(savingContext); + } + private bool IsHomePage(IContent content) { var homepage = _aliasService.Get(String.Empty); var displayRouteValues = _contentManager.GetItemMetadata(content).DisplayRouteValues; diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Helpers/MetaDataExtensions.cs b/src/Orchard.Web/Modules/Orchard.Layouts/Helpers/MetaDataExtensions.cs index 0464c6644..aebdde50e 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Helpers/MetaDataExtensions.cs +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Helpers/MetaDataExtensions.cs @@ -5,5 +5,9 @@ namespace Orchard.Layouts.Helpers { public static ContentPartDefinitionBuilder Placeable(this ContentPartDefinitionBuilder builder, bool placeable = true) { return builder.WithSetting("ContentPartLayoutSettings.Placeable", placeable.ToString()); } + + public static ContentTypeDefinitionBuilder Placeable(this ContentTypeDefinitionBuilder builder, bool placeable = true) { + return builder.WithSetting("ContentTypeLayoutSettings.Placeable", placeable.ToString()); + } } } diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Helpers/PlaceableContentExtensions.cs b/src/Orchard.Web/Modules/Orchard.Layouts/Helpers/PlaceableContentExtensions.cs new file mode 100644 index 000000000..498db8c34 --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Helpers/PlaceableContentExtensions.cs @@ -0,0 +1,14 @@ +using Orchard.ContentManagement; +using Orchard.ContentManagement.FieldStorage.InfosetStorage; + +namespace Orchard.Layouts.Helpers { + public static class PlaceableContentExtensions { + public static bool IsPlaceableContent(this IContent content) { + return content.As().Retrieve("PlacedAsElement"); + } + + public static void IsPlaceableContent(this IContent content, bool value) { + content.As().Store("PlacedAsElement", value); + } + } +} \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Module.txt b/src/Orchard.Web/Modules/Orchard.Layouts/Module.txt index 4f21508df..55e7dd8b7 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Module.txt +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Module.txt @@ -10,7 +10,7 @@ Features: Orchard.Layouts: Name: Layouts Description: Provides tools to create layouts. - Dependencies: Common, Orchard.jQuery, Orchard.Forms, Orchard.Tokens, Orchard.MediaLibrary, Orchard.Widgets + Dependencies: Common, Orchard.jQuery, Orchard.Forms, Orchard.Tokens, Orchard.MediaLibrary, Orchard.Conditions Category: Layout Orchard.Layouts.Snippets: Name: Layout Snippets diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Orchard.Layouts.csproj b/src/Orchard.Web/Modules/Orchard.Layouts/Orchard.Layouts.csproj index 8771e0175..c379d3a19 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Orchard.Layouts.csproj +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Orchard.Layouts.csproj @@ -79,15 +79,13 @@ + - - - @@ -292,6 +290,10 @@ {66fccd76-2761-47e3-8d11-b45d0001ddaa} Orchard.Autoroute + + {98251eae-a41b-47b2-aa91-e28b8482da70} + Orchard.Conditions + {642a49d7-8752-4177-80d6-bfbbcfad3de0} Orchard.Forms @@ -313,10 +315,6 @@ {6f759635-13d7-4e94-bcc9-80445d63f117} Orchard.Tokens - - {194d3ccc-1153-474d-8176-fde8d7d0d0bd} - Orchard.Widgets - @@ -338,6 +336,7 @@ + @@ -360,6 +359,7 @@ + @@ -368,6 +368,9 @@ + + + @@ -393,6 +396,8 @@ + + @@ -429,9 +434,9 @@ - + - + @@ -591,6 +596,18 @@ + + + + + + + + + + + + 10.0 $(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion) diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Providers/PlaceableContentElementHarvester.cs b/src/Orchard.Web/Modules/Orchard.Layouts/Providers/PlaceableContentElementHarvester.cs new file mode 100644 index 000000000..3a7d37ab8 --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Providers/PlaceableContentElementHarvester.cs @@ -0,0 +1,174 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using Orchard.ContentManagement; +using Orchard.ContentManagement.Aspects; +using Orchard.ContentManagement.MetaData.Models; +using Orchard.Core.Contents.Settings; +using Orchard.Environment; +using Orchard.Layouts.Elements; +using Orchard.Layouts.Framework.Display; +using Orchard.Layouts.Framework.Drivers; +using Orchard.Layouts.Framework.Elements; +using Orchard.Layouts.Framework.Harvesters; +using Orchard.Layouts.Helpers; +using Orchard.Layouts.Settings; +using Orchard.Layouts.ViewModels; +using ContentItem = Orchard.ContentManagement.ContentItem; + +namespace Orchard.Layouts.Providers { + public class PlaceableContentElementHarvester : Component, IElementHarvester { + private readonly Work _contentManager; + + public PlaceableContentElementHarvester(Work contentManager) { + _contentManager = contentManager; + } + + public IEnumerable HarvestElements(HarvestElementsContext context) { + var contentTypeDefinitions = GetPlaceableContentTypeDefinitions(); + + return contentTypeDefinitions.Select(contentTypeDefinition => { + var settings = contentTypeDefinition.Settings; + var description = settings.ContainsKey("Description") ? settings["Description"] : contentTypeDefinition.DisplayName; + return new ElementDescriptor(typeof (PlaceableContentItem), contentTypeDefinition.Name, T(contentTypeDefinition.DisplayName), T(description), category: "Content Items") { + Displaying = Displaying, + Editor = Editor, + UpdateEditor = UpdateEditor, + ToolboxIcon = "\uf1b2", + EnableEditorDialog = true, + Removing = RemoveContentItem, + Exporting = ExportElement, + Importing = ImportElement, + StateBag = new Dictionary { + { "ContentTypeName", contentTypeDefinition.Name } + } + }; + }); + } + + private void Displaying(ElementDisplayingContext context) { + var contentTypeName = (string)context.Element.Descriptor.StateBag["ContentTypeName"]; + var element = (PlaceableContentItem)context.Element; + var contentItemId = element.ContentItemId; + var versionOptions = context.DisplayType == "Design" ? VersionOptions.Latest : VersionOptions.Published; + var contentItem = contentItemId != null + ? _contentManager.Value.Get(contentItemId.Value, versionOptions) + : _contentManager.Value.New(contentTypeName); + + var contentShape = contentItem != null ? _contentManager.Value.BuildDisplay(contentItem) : default(dynamic); + context.ElementShape.ContentItem = contentItem; + context.ElementShape.ContentShape = contentShape; + } + + private void Editor(ElementEditorContext context) { + UpdateEditor(context); + } + + private void UpdateEditor(ElementEditorContext context) { + var contentTypeName = (string)context.Element.Descriptor.StateBag["ContentTypeName"]; + var element = (PlaceableContentItem) context.Element; + var elementViewModel = new PlaceableContentItemViewModel { + ContentItemId = element.ContentItemId + }; + + if (context.Updater != null) { + context.Updater.TryUpdateModel(elementViewModel, context.Prefix, null, null); + } + + var contentItemId = elementViewModel.ContentItemId; + var contentItem = contentItemId != null + ? _contentManager.Value.Get(contentItemId.Value, VersionOptions.Latest) + : _contentManager.Value.New(contentTypeName); + + dynamic contentEditorShape; + + if (context.Updater != null) { + if (contentItem.Id == 0) { + _contentManager.Value.Create(contentItem, VersionOptions.Draft); + } + else { + var isDraftable = contentItem.TypeDefinition.Settings.GetModel().Draftable; + var versionOptions = isDraftable ? VersionOptions.DraftRequired : VersionOptions.Latest; + contentItem = _contentManager.Value.Get(contentItem.Id, versionOptions); + } + + element.ContentItemId = contentItem.Id; + + // If the placed content item has the CommonPart attached, set its Container property to the Content (if any). + // This helps preventing widget types from appearing as orphans. + var commonPart = contentItem.As(); + if (commonPart != null) + commonPart.Container = context.Content; + + contentItem.IsPlaceableContent(true); + contentEditorShape = _contentManager.Value.UpdateEditor(contentItem, context.Updater); + + _contentManager.Value.Publish(contentItem); + } + else { + contentEditorShape = _contentManager.Value.BuildEditor(contentItem); + } + + var elementEditorShape = context.ShapeFactory.EditorTemplate(TemplateName: "Elements.PlaceableContentItem", Model: elementViewModel, Prefix: context.Prefix); + + elementEditorShape.Metadata.Position = "Properties:0"; + contentEditorShape.Metadata.Position = "Properties:0"; + context.EditorResult.Add(elementEditorShape); + context.EditorResult.Add(contentEditorShape); + } + + private void RemoveContentItem(ElementRemovingContext context) { + var element = (PlaceableContentItem) context.Element; + var contentItemId = element.ContentItemId; + + // Only remove the content item if no other elements are referencing this one. + // This can happen if the user cut an element and then pasted it back. + // That will delete the initial element and create a copy. + var placeableElements = + from e in context.Elements.Flatten() + let p = e as PlaceableContentItem + where p != null && p.ContentItemId == contentItemId + select p; + + if (placeableElements.Any()) + return; + + var contentItem = contentItemId != null ? _contentManager.Value.Get(contentItemId.Value, VersionOptions.Latest) : default(ContentItem); + + if(contentItem != null) + _contentManager.Value.Remove(contentItem); + } + + private void ExportElement(ExportElementContext context) { + var element = (PlaceableContentItem)context.Element; + var contentItemId = element.ContentItemId; + var contentItem = contentItemId != null ? _contentManager.Value.Get(contentItemId.Value, VersionOptions.Latest) : default(ContentItem); + var contentItemIdentity = contentItem != null ? _contentManager.Value.GetItemMetadata(contentItem).Identity.ToString() : default(string); + + if (contentItemIdentity != null) + context.ExportableData["ContentItemId"] = contentItemIdentity; + } + + private void ImportElement(ImportElementContext context) { + var contentItemIdentity = context.ExportableData.Get("ContentItemId"); + + if (String.IsNullOrWhiteSpace(contentItemIdentity)) + return; + + var contentItem = context.Session.GetItemFromSession(contentItemIdentity); + var element = (PlaceableContentItem)context.Element; + + element.ContentItemId = contentItem != null ? contentItem.Id : default(int?); + } + + private IEnumerable GetPlaceableContentTypeDefinitions() { + // Select all types that have either "Placeable" set to true. + var contentTypeDefinitionsQuery = + from contentTypeDefinition in _contentManager.Value.GetContentTypeDefinitions() + where contentTypeDefinition.Settings.GetModel().Placeable + select contentTypeDefinition; + + return contentTypeDefinitionsQuery.ToList(); + } + } +} \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/DemoConfig.js b/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/DemoConfig.js deleted file mode 100644 index 75b2f50e6..000000000 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/DemoConfig.js +++ /dev/null @@ -1,50 +0,0 @@ -var demoConfig = { - "createContentUrl": "/Modules/Orchard.Layouts/Controller/Create/{contentTypeId}", - "editContentUrl": "/Modules/Orchard.Layouts/Controller/Edit/{contentTypeId}", - "categories": [ - { - "name": "Content", - "contentTypes": [ - { "label": "Content Item", "id": "Orchard.Layouts.Elements.ContentItem" }, - { "label": "Html", "id": "Orchard.Layouts.Elements.Html" }, - { "label": "Paragraph", "id": "Orchard.Layouts.Elements.Paragraph" }, - { "label": "Text", "id": "Orchard.Layouts.Elements.Text" } - ] - }, - { - "name": "Media", - "contentTypes": [ - { "label": "Image", "id": "Orchard.Layouts.Elements.Image" }, - { "label": "Media Item", "id": "Orchard.Layouts.Elements.MediaItem" }, - { "label": "Vector Image", "id": "Orchard.Layouts.Elements.VectorImage" } - ] - }, - { - "name": "Parts", - "contentTypes": [ - { "label": "CommonPart", "id": "CommonPart" }, - { "label": "TitlePart", "id": "TitlePart" } - ] - }, - { - "name": "Forms", - "contentTypes": [ - { "label": "Button", "id": "Orchard.DynamicForms.Elements.Button" }, - { "label": "Check Box", "id": "Orchard.DynamicForms.Elements.CheckBox" }, - { "label": "Email Field", "id": "Orchard.DynamicForms.Elements.EmailField" }, - { "label": "Enumeration", "id": "Orchard.DynamicForms.Elements.Enumeration" }, - { "label": "Form", "id": "Orchard.DynamicForms.Elements.Form" }, - { "label": "Hidden Field", "id": "Orchard.DynamicForms.Elements.HiddenField" }, - { "label": "Ip Address Field", "id": "Orchard.DynamicForms.Elements.IpAddressField" }, - { "label": "Label", "id": "Orchard.DynamicForms.Elements.Label" }, - { "label": "Password Field", "id": "Orchard.DynamicForms.Elements.PasswordField" }, - { "label": "Radio Button", "id": "Orchard.DynamicForms.Elements.RadioButton" }, - { "label": "Text Area", "id": "Orchard.DynamicForms.Elements.TextArea" }, - { "label": "Text Field", "id": "Orchard.DynamicForms.Elements.TextField" }, - { "label": "User Name Field", "id": "Orchard.DynamicForms.Elements.UserNameField" }, - { "label": "Validation Message", "id": "Orchard.DynamicForms.Elements.ValidationMessage" }, - { "label": "Validation Summary", "id": "Orchard.DynamicForms.Elements.ValidationSummary" } - ] - } - ] -}; diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/DemoData.js b/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/DemoData.js deleted file mode 100644 index 27f15d98e..000000000 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/DemoData.js +++ /dev/null @@ -1,261 +0,0 @@ -var demoData = { - "type": "Canvas", - "data": null, - "htmlId": null, - "htmlClass": null, - "htmlStyle": null, - "children": [ - { - "type": "Grid", - "data": null, - "htmlId": null, - "htmlClass": null, - "htmlStyle": null, - "children": [ - { - "type": "Row", - "data": null, - "htmlId": null, - "htmlClass": null, - "htmlStyle": null, - "children": [ - { - "type": "Column", - "data": null, - "htmlId": null, - "htmlClass": null, - "htmlStyle": null, - "width": 4, - "offset": 0, - "children": [ - { - "type": "Content", - "data": null, - "htmlId": null, - "htmlClass": null, - "htmlStyle": null, - "contentType": "Image", - "html": "" - } - ] - }, - { - "type": "Column", - "data": null, - "htmlId": null, - "htmlClass": null, - "htmlStyle": null, - "width": 8, - "offset": 0, - "children": [ - { - "type": "Content", - "data": null, - "htmlId": null, - "htmlClass": null, - "htmlStyle": null, - "contentType": "HTML", - "html": "

Who are we?

" - }, - { - "type": "Content", - "data": null, - "htmlId": null, - "htmlClass": null, - "htmlStyle": null, - "contentType": "Vector Image", - "html": "" - }, - { - "type": "Content", - "data": null, - "htmlId": null, - "htmlClass": null, - "htmlStyle": null, - "contentType": "HTML", - "html": "

IDeliverable is a company of like-minded individuals with a true passion for .NET based software development and cloud computing.

" - } - ] - } - ] - }, - { - "type": "Row", - "data": null, - "htmlId": null, - "htmlClass": null, - "htmlStyle": null, - "children": [ - { - "type": "Column", - "data": null, - "htmlId": null, - "htmlClass": null, - "htmlStyle": null, - "width": 12, - "offset": 0, - "children": [ - { - "type": "Content", - "data": null, - "htmlId": null, - "htmlClass": null, - "htmlStyle": null, - "contentType": "HTML", - "html": "

What do we do?

We provide software development, consulting and training within our three areas of focus.

" - } - ] - } - ] - }, - { - "type": "Row", - "data": null, - "htmlId": null, - "htmlClass": null, - "htmlStyle": null, - "children": [ - { - "type": "Column", - "data": null, - "htmlId": null, - "htmlClass": null, - "htmlStyle": null, - "width": 4, - "offset": 0, - "children": [ - { - "type": "Content", - "data": null, - "htmlId": null, - "htmlClass": null, - "htmlStyle": null, - "contentType": "HTML", - "html": "

.NET software development

Microsoft .NET is at the core of everything we do. We have worked with .NET since its inception back in 2000 and are exceptionally proficient in all aspects of the platform, including its languages, frameworks, services and tools. Whether it’s the latest ASP.NET technologies with HTML5, CSS3 and modern JavaScript frameworks, Windows Phone and Windows Store apps with XAML, or more enterprise oriented Windows Forms or WPF rich client apps with WCF based service back ends, we’ve done it all for years and feel right at home.

" - } - ] - }, - { - "type": "Column", - "data": null, - "htmlId": null, - "htmlClass": null, - "htmlStyle": null, - "width": 4, - "offset": 0, - "children": [ - { - "type": "Content", - "data": null, - "htmlId": null, - "htmlClass": null, - "htmlStyle": null, - "contentType": "HTML", - "html": "

Microsoft Azure

We are true believers in cloud computing, and as far as hosting goes, we believe there’s no better home for .NET based applications than Microsoft Azure. And so we have worked hard in the past few years to become experts in every nook and cranny of this platform. Our expertise includes architecting and designing applications for Microsoft Azure, adapting and migrating existing applications to Microsoft Azure, automating Microsoft Azure deployment and building hybrid solutions involving both on-premises components and Microsoft Azure.

" - } - ] - }, - { - "type": "Column", - "data": null, - "htmlId": null, - "htmlClass": null, - "htmlStyle": null, - "width": 4, - "offset": 0, - "children": [ - { - "type": "Content", - "data": null, - "htmlId": null, - "htmlClass": null, - "htmlStyle": null, - "contentType": "HTML", - "html": "

Orchard CMS

" - }, - { - "type": "Grid", - "data": null, - "htmlId": null, - "htmlClass": null, - "htmlStyle": null, - "children": [ - { - "type": "Row", - "data": null, - "htmlId": null, - "htmlClass": null, - "htmlStyle": null, - "children": [ - { - "type": "Column", - "data": null, - "htmlId": null, - "htmlClass": null, - "htmlStyle": null, - "width": 4, - "offset": 0, - "children": [ - { - "type": "Content", - "data": null, - "htmlId": null, - "htmlClass": null, - "htmlStyle": null, - "contentType": "HTML", - "html": "

When it comes to web site development, the Orchard CMS is our framework of choice.

" - } - ] - }, - { - "type": "Column", - "data": null, - "htmlId": null, - "htmlClass": null, - "htmlStyle": null, - "width": 4, - "offset": 0, - "children": [ - { - "type": "Content", - "data": null, - "htmlId": null, - "htmlClass": null, - "htmlStyle": null, - "contentType": "HTML", - "html": "

We have worked with Orchard for almost three years and have built a wide array of web sites, large and small, using it. We have two developers who participate actively in the development of Orchard and who have commit rights in the official Orchard source code repository.

" - } - ] - }, - { - "type": "Column", - "data": null, - "htmlId": null, - "htmlClass": null, - "htmlStyle": null, - "width": 4, - "offset": 0, - "children": [ - { - "type": "Content", - "data": null, - "htmlId": null, - "htmlClass": null, - "htmlStyle": null, - "contentType": "HTML", - "html": "

One of them is even on the Orchard steering committee, so it’s fair to say we have our ears to the ground when it comes to what’s happening in the Orchard community.

" - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] - } - ] -} diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/LayoutDesignerHost.js b/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/LayoutDesignerHost.js index 2ac119d0a..b4a68a445 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/LayoutDesignerHost.js +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/LayoutDesignerHost.js @@ -4,7 +4,6 @@ this.element = element; this.element.data("layout-designer-host", this); this.editor = window.layoutEditor; - this.isFormSubmitting = false; this.settings = { antiForgeryToken: self.element.data("anti-forgery-token"), editorDialogTitleFormat: self.element.data("editor-dialog-title-format"), @@ -62,6 +61,11 @@ return JSON.stringify(layoutData, null, "\t"); }; + var serializeRecycleBin = function () { + var recycleBinData = self.editor.recycleBin.toObject(); + return JSON.stringify(recycleBinData, null, "\t"); + }; + var applyTemplate = function (templateId) { var layoutData = serializeCanvas(); @@ -79,21 +83,23 @@ }); }; - var monitorForm = function() { - var layoutDesigner = self.element; - var form = layoutDesigner.closest("form"); - + var monitorForm = function () { + var form = $(".zone-content form:first"); + form.on("submit", function (e) { - self.isFormSubmitting = true; + form.attr("isSubmitting", true); serializeLayout(); }); }; var serializeLayout = function () { var layoutDataField = self.element.find(".layout-data-field"); + var recycleBinDataField = self.element.find(".recycle-bin-data-field"); var layoutDataDataJson = serializeCanvas(); + var recycleBinDataJson = serializeRecycleBin(); layoutDataField.val(layoutDataDataJson); + recycleBinDataField.val(recycleBinDataJson); }; this.element.on("change", ".template-picker select", function (e) { @@ -103,7 +109,10 @@ }); $(window).on("beforeunload", function () { - if (!self.isFormSubmitting && self.editor.isDirty()) + + var form = $(".zone-content form:first"); + var isFormSubmitting = form.attr("isSubmitting"); + if (!isFormSubmitting && self.editor.isDirty()) return "You have unsaved changes."; return undefined; @@ -118,7 +127,7 @@ window.Orchard.Layouts.LayoutEditorHost = window.Orchard.Layouts.LayoutEditorHost || {}; $(function () { - var host = new LayoutDesignerHost($(".layout-designer")); + window.layoutDesignerHost = new LayoutDesignerHost($(".layout-designer")); $(".layout-designer").each(function (e) { var designer = $(this); var dialog = designer.find(".layout-editor-help-dialog"); diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/Models.js b/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/Models.js index 9e2971ba2..0299e2362 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/Models.js +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/Models.js @@ -58,6 +58,7 @@ var LayoutEditor; this.dropTargetElement = null; this.isDragging = false; this.isResizing = false; + this.recycleBin = new LayoutEditor.RecycleBin(); this.resetToolboxElements = function () { this.toolboxElements = [ @@ -78,6 +79,34 @@ var LayoutEditor; })(LayoutEditor || (LayoutEditor = {})); +var LayoutEditor; +(function (LayoutEditor) { + + LayoutEditor.RecycleBin = function () { + this.elements = []; + + this.add = function(element) { + this.elements.push(element); + }; + + this.toObject = function () { + var result = { + type: "RecycleBin", + children: [] + }; + + for (var i = 0; i < this.elements.length; i++) { + var element = this.elements[i]; + var dto = element.toObject(); + result.children.push(dto); + } + + return result; + }; + }; + +})(LayoutEditor || (LayoutEditor = {})); + var LayoutEditor; (function (LayoutEditor) { @@ -154,9 +183,9 @@ var LayoutEditor; this.setIsFocused = function () { if (!this.editor) - return; + return; if (!this.children && this.isTemplated) - return; + return; if (this.editor.isDragging || this.editor.isResizing) return; @@ -208,7 +237,7 @@ var LayoutEditor; this.delete = function () { if (!this.canDelete()) return; - this.parent.deleteChild(this); + this.parent.deleteChild(this); }; this.canMoveUp = function () { @@ -220,7 +249,7 @@ var LayoutEditor; this.moveUp = function () { if (!this.canMoveUp()) return; - this.parent.moveChildUp(this); + this.parent.moveChildUp(this); }; this.canMoveDown = function () { @@ -232,7 +261,7 @@ var LayoutEditor; this.moveDown = function () { if (!this.canMoveDown()) return; - this.parent.moveChildDown(this); + this.parent.moveChildDown(this); }; this.elementToObject = function () { @@ -262,8 +291,8 @@ var LayoutEditor; this.cut = function (clipboardData) { if (this.canDelete()) { - this.copy(clipboardData); - this.delete(); + this.copy(clipboardData); + this.delete(); } }; @@ -322,6 +351,7 @@ var LayoutEditor; var index = _(this.children).indexOf(child); if (index >= 0) { this.children.splice(index, 1); + this.editor.recycleBin.add(child); if (child.getIsActive()) this.editor.activeElement = null; if (child.getIsFocused()) { @@ -431,7 +461,7 @@ var LayoutEditor; result.children = this.childrenToObject(); return result; }; - }; + }; LayoutEditor.Canvas.from = function (value) { var result = new LayoutEditor.Canvas( diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/contentpart-layouts-settings.js b/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/contentpart-layouts-settings.js deleted file mode 100644 index 99f4e8704..000000000 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/contentpart-layouts-settings.js +++ /dev/null @@ -1,19 +0,0 @@ -(function ($) { - var placeable = $("input[name=\"ContentPartLayoutSettings.Placeable\"]"); - - $(placeable).on("change", function (e) { - syncEnableEditorInput(); - }); - - $(function () { - syncEnableEditorInput(); - }); - - var syncEnableEditorInput = function () { - var enableEditorDialog = $("input[name=\"ContentPartLayoutSettings.EnableEditorDialog\"]"); - var isPlaceable = placeable.is(":checked"); - - enableEditorDialog.prop("disabled", !isPlaceable); - }; - -})(jQuery); \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/dialog.js b/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/dialog.js index c2843396f..d7c4bd15e 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/dialog.js +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Scripts/dialog.js @@ -76,8 +76,6 @@ $(document).off("keyup", onKeyUp); closedDialogs.push(self); - - }; this.load = function (url, data, method) { @@ -135,8 +133,8 @@ if (self.frame == null) return; - self.frame.element.height($(window).height() * .75); - self.frame.element.width($(window).width() * .75); + self.frame.element.height($(window).height() * .80); + self.frame.element.width($(window).width() * .87); }; var resizeView = function () { diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Services/DefaultModelMaps.cs b/src/Orchard.Web/Modules/Orchard.Layouts/Services/DefaultModelMaps.cs index 51391b64a..d463892ee 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Services/DefaultModelMaps.cs +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Services/DefaultModelMaps.cs @@ -45,7 +45,7 @@ namespace Orchard.Layouts.Services { element.HtmlClass = (string)node["htmlClass"]; element.HtmlStyle = (string)node["htmlStyle"]; element.IsTemplated = (bool)(node["isTemplated"] ?? false); - element.Rule = (string) node["rule"]; + element.Rule = (string)node["rule"]; } protected bool? ReadBoolean(JToken node) { @@ -113,7 +113,7 @@ namespace Orchard.Layouts.Services { element.HtmlClass = (string)node["htmlClass"]; element.HtmlStyle = (string)node["htmlStyle"]; element.IsTemplated = (bool)(node["isTemplated"] ?? false); - element.Rule = (string) node["rule"]; + element.Rule = (string)node["rule"]; return element; } @@ -125,7 +125,7 @@ namespace Orchard.Layouts.Services { node["htmlStyle"] = element.HtmlStyle; node["rule"] = element.Rule; node["isTemplated"] = element.IsTemplated; - node["hasEditor"] = element.HasEditor; + node["hasEditor"] = element.Descriptor.EnableEditorDialog; node["contentType"] = element.Descriptor.TypeName; node["contentTypeLabel"] = element.Descriptor.DisplayText.Text; node["contentTypeClass"] = element.DisplayText.Text.HtmlClassify(); @@ -161,4 +161,19 @@ namespace Orchard.Layouts.Services { return element; } } + + public class RecycleBinModelMap : ILayoutModelMap { + public int Priority { get { return 0; } } + public string LayoutElementType { get { return "RecycleBin"; } } + public bool CanMap(Element element) { + return element.Type == "RecycleBin"; + } + + public Element ToElement(IElementManager elementManager, DescribeElementsContext describeContext, JToken node) { + return new RecycleBin(); + } + + public void FromElement(Element element, DescribeElementsContext describeContext, JToken node) { + } + } } \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Services/ElementEventHandlerBase.cs b/src/Orchard.Web/Modules/Orchard.Layouts/Services/ElementEventHandlerBase.cs index b84fb2049..1a612824d 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Services/ElementEventHandlerBase.cs +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Services/ElementEventHandlerBase.cs @@ -1,14 +1,22 @@ using Orchard.Layouts.Framework.Display; using Orchard.Layouts.Framework.Drivers; +using Orchard.Layouts.Framework.Elements; namespace Orchard.Layouts.Services { public abstract class ElementEventHandlerBase : Component, IElementEventHandler { public virtual void Creating(ElementCreatingContext context) { } public virtual void Created(ElementCreatedContext context) { } - public virtual void CreatingDisplay(ElementCreatingDisplayShapeContext context) {} + public virtual void CreatingDisplay(ElementCreatingDisplayShapeContext context) { } public virtual void Displaying(ElementDisplayingContext context) { } public virtual void Displayed(ElementDisplayedContext context) { } public virtual void BuildEditor(ElementEditorContext context) { } public virtual void UpdateEditor(ElementEditorContext context) { } + public virtual void LayoutSaving(ElementSavingContext context) { } + public virtual void Removing(ElementRemovingContext context) { } + public virtual void Exporting(ExportElementContext context) { } + public virtual void Exported(ExportElementContext context) { } + public virtual void Importing(ImportElementContext context) { } + public virtual void Imported(ImportElementContext context) { } + public virtual void ImportCompleted(ImportElementContext context) { } } } \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Services/ElementManager.cs b/src/Orchard.Web/Modules/Orchard.Layouts/Services/ElementManager.cs index c48d5b502..863672541 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Services/ElementManager.cs +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Services/ElementManager.cs @@ -55,21 +55,21 @@ namespace Orchard.Layouts.Services { public IEnumerable GetCategories(DescribeElementsContext context) { var contentType = context.Content != null ? context.Content.ContentItem.ContentType : default(string); - return _cacheManager.Get(String.Format("ElementCategories-{0}-{1}", contentType ?? "AnyType", context.CacheVaryParam), true, acquireContext => { - var elements = DescribeElements(context); + return _cacheManager.Get(String.Format("ElementCategories-{0}-{1}", contentType ?? "AnyType", context.CacheVaryParam), acquireContext => { + var elementDescriptors = DescribeElements(context); var categoryDictionary = GetCategories(); var categoryDescriptorDictionary = new Dictionary(); - foreach (var element in elements) { - var category = categoryDictionary.ContainsKey(element.Category) - ? categoryDictionary[element.Category] - : new Category(element.Category, T(element.Category), position: int.MaxValue); + foreach (var elementDescriptor in elementDescriptors) { + var category = categoryDictionary.ContainsKey(elementDescriptor.Category) + ? categoryDictionary[elementDescriptor.Category] + : new Category(elementDescriptor.Category, T(elementDescriptor.Category), position: int.MaxValue); - var descriptor = categoryDescriptorDictionary.ContainsKey(element.Category) - ? categoryDescriptorDictionary[element.Category] - : categoryDescriptorDictionary[element.Category] = new CategoryDescriptor(category.Name, category.DisplayName, category.Description, category.Position); + var descriptor = categoryDescriptorDictionary.ContainsKey(elementDescriptor.Category) + ? categoryDescriptorDictionary[elementDescriptor.Category] + : categoryDescriptorDictionary[elementDescriptor.Category] = new CategoryDescriptor(category.Name, category.DisplayName, category.Description, category.Position); - descriptor.Elements.Add(element); + descriptor.Elements.Add(elementDescriptor); } acquireContext.Monitor(_signals.When(Signals.ElementDescriptors)); @@ -141,76 +141,68 @@ namespace Orchard.Layouts.Services { public void Saving(LayoutSavingContext context) { var elements = context.Elements.Flatten(); - InvokeDriver(elements, (driver, element) => driver.LayoutSaving(new ElementSavingContext(context) { - Element = element - })); + + foreach (var element in elements) { + var savingContext = new ElementSavingContext(element, context); + _elementEventHandler.LayoutSaving(savingContext); + element.Descriptor.LayoutSaving(savingContext); + } } public void Removing(LayoutSavingContext context) { - var elementInstances = context.RemovedElements.Flatten(); - InvokeDriver(elementInstances, (driver, elementInstance) => driver.Removing(new ElementRemovingContext(context) { - Element = elementInstance - })); + var elements = context.RemovedElements.Flatten().ToList(); + + foreach (var element in elements) { + var removingContext = new ElementRemovingContext(element, context.Elements, context.RemovedElements, context.Content); + _elementEventHandler.Removing(removingContext); + element.Descriptor.Removing(removingContext); + } } public void Exporting(IEnumerable elements, ExportLayoutContext context) { - InvokeDriver(elements, (driver, element) => { - var exportElementContext = new ExportElementContext { - Layout = context.Layout, - Element = element, - ExportableData = element.ExportableData - }; - driver.Exporting(exportElementContext); - element.ExportableData = new ElementDataDictionary(exportElementContext.ExportableData); - }); + foreach (var element in elements) { + var exportingContext = new ExportElementContext(element, context.Layout, element.ExportableData ?? new ElementDataDictionary()); + _elementEventHandler.Exporting(exportingContext); + element.Descriptor.Exporting(exportingContext); + + // Update potentially modified ExportableData. + element.ExportableData = new ElementDataDictionary(exportingContext.ExportableData); + } } public void Exported(IEnumerable elements, ExportLayoutContext context) { - InvokeDriver(elements, (driver, element) => { - var exportElementContext = new ExportElementContext { - Layout = context.Layout, - Element = element, - ExportableData = element.ExportableData - }; - driver.Exported(exportElementContext); - element.ExportableData = new ElementDataDictionary(exportElementContext.ExportableData); - }); + foreach (var element in elements) { + var exportingContext = new ExportElementContext(element, context.Layout, element.ExportableData ?? new ElementDataDictionary()); + _elementEventHandler.Exported(exportingContext); + element.Descriptor.Exported(exportingContext); + + // Update potentially modified ExportableData. + element.ExportableData = new ElementDataDictionary(exportingContext.ExportableData); + } } public void Importing(IEnumerable elements, ImportLayoutContext context) { - InvokeDriver(elements, (driver, element) => { - var importElementContext = new ImportElementContext { - Layout = context.Layout, - Element = element, - ExportableData = element.ExportableData, - Session = context.Session - }; - driver.Importing(importElementContext); - }); + foreach (var element in elements) { + var importingContext = new ImportElementContext(element, context.Layout, element.ExportableData ?? new ElementDataDictionary(), context.Session); + _elementEventHandler.Importing(importingContext); + element.Descriptor.Importing(importingContext); + } } public void Imported(IEnumerable elements, ImportLayoutContext context) { - InvokeDriver(elements, (driver, element) => { - var importElementContext = new ImportElementContext { - Layout = context.Layout, - Element = element, - ExportableData = element.ExportableData, - Session = context.Session - }; - driver.Imported(importElementContext); - }); + foreach (var element in elements) { + var importingContext = new ImportElementContext(element, context.Layout, element.ExportableData ?? new ElementDataDictionary(), context.Session); + _elementEventHandler.Imported(importingContext); + element.Descriptor.Imported(importingContext); + } } public void ImportCompleted(IEnumerable elements, ImportLayoutContext context) { - InvokeDriver(elements, (driver, element) => { - var importElementContext = new ImportElementContext { - Layout = context.Layout, - Element = element, - ExportableData = element.ExportableData, - Session = context.Session - }; - driver.ImportCompleted(importElementContext); - }); + foreach (var element in elements) { + var importingContext = new ImportElementContext(element, context.Layout, element.ExportableData ?? new ElementDataDictionary(), context.Session); + _elementEventHandler.ImportCompleted(importingContext); + element.Descriptor.ImportCompleted(importingContext); + } } private IDictionary GetCategories() { @@ -225,15 +217,6 @@ namespace Orchard.Layouts.Services { return dictionary; } - private void InvokeDriver(IEnumerable elements, Action driverAction) { - foreach (var element in elements) { - var drivers = GetDrivers(element.Descriptor); - foreach (var driver in drivers) { - driverAction(driver, element); - } - } - } - private static bool IsElementType(IElementDriver elementDriver, Type elementType) { var driverType = elementDriver.GetType(); var driverElementType = driverType.BaseType.GenericTypeArguments[0]; diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Services/IElementEventHandler.cs b/src/Orchard.Web/Modules/Orchard.Layouts/Services/IElementEventHandler.cs index 6ba089a94..578530c07 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Services/IElementEventHandler.cs +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Services/IElementEventHandler.cs @@ -1,6 +1,7 @@ using Orchard.Events; using Orchard.Layouts.Framework.Display; using Orchard.Layouts.Framework.Drivers; +using Orchard.Layouts.Framework.Elements; namespace Orchard.Layouts.Services { public interface IElementEventHandler : IEventHandler { @@ -11,5 +12,12 @@ namespace Orchard.Layouts.Services { void Displayed(ElementDisplayedContext context); void BuildEditor(ElementEditorContext context); void UpdateEditor(ElementEditorContext context); + void LayoutSaving(ElementSavingContext context); + void Removing(ElementRemovingContext context); + void Exporting(ExportElementContext context); + void Exported(ExportElementContext context); + void Importing(ImportElementContext context); + void Imported(ImportElementContext context); + void ImportCompleted(ImportElementContext context); } } \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Services/LayoutEditorFactory.cs b/src/Orchard.Web/Modules/Orchard.Layouts/Services/LayoutEditorFactory.cs index 56849f50d..bcf039627 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Services/LayoutEditorFactory.cs +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Services/LayoutEditorFactory.cs @@ -76,7 +76,7 @@ namespace Orchard.Layouts.Services { icon = descriptor.ToolboxIcon, hasEditor = descriptor.EnableEditorDialog, - // If the element has no editor then the toolbox will add the element straight to to designer when being dragged & dropped, + // If the element has no editor then the toolbox will add the element straight to the designer when being dragged & dropped, // so we'll want to present the user with a prerendered element. html = descriptor.EnableEditorDialog ? "" : RenderElement(element, new DescribeElementsContext { Content = content }) }; diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Settings/ContentPartLayoutSettings.cs b/src/Orchard.Web/Modules/Orchard.Layouts/Settings/ContentPartLayoutSettings.cs index 7cd2f622d..de763b862 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Settings/ContentPartLayoutSettings.cs +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Settings/ContentPartLayoutSettings.cs @@ -1,7 +1,7 @@ namespace Orchard.Layouts.Settings { public class ContentPartLayoutSettings { /// - /// This setting is used to configure a part to be placeable on a layout. + /// This setting is used to configure a content part to be placeable on a layout. /// public bool Placeable { get; set; } } diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Settings/ContentPartSettingsHooks.cs b/src/Orchard.Web/Modules/Orchard.Layouts/Settings/ContentPartLayoutSettingsHooks.cs similarity index 91% rename from src/Orchard.Web/Modules/Orchard.Layouts/Settings/ContentPartSettingsHooks.cs rename to src/Orchard.Web/Modules/Orchard.Layouts/Settings/ContentPartLayoutSettingsHooks.cs index 440f7e5d7..e63cbebc2 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Settings/ContentPartSettingsHooks.cs +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Settings/ContentPartLayoutSettingsHooks.cs @@ -7,7 +7,7 @@ using Orchard.ContentManagement.ViewModels; using Orchard.Layouts.Helpers; namespace Orchard.Layouts.Settings { - public class ContentPartSettingsHooks : ContentDefinitionEditorEventsBase { + public class ContentPartLayoutSettingsHooks : ContentDefinitionEditorEventsBase { public override IEnumerable PartEditor(ContentPartDefinition definition) { var model = definition.Settings.GetModel(); diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Settings/ContentTypeLayoutSettings.cs b/src/Orchard.Web/Modules/Orchard.Layouts/Settings/ContentTypeLayoutSettings.cs new file mode 100644 index 000000000..bf4acc405 --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Settings/ContentTypeLayoutSettings.cs @@ -0,0 +1,8 @@ +namespace Orchard.Layouts.Settings { + public class ContentTypeLayoutSettings { + /// + /// This setting is used to configure a content type to be placeable on a layout. + /// + public bool Placeable { get; set; } + } +} \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Settings/ContentTypeLayoutSettingsHooks.cs b/src/Orchard.Web/Modules/Orchard.Layouts/Settings/ContentTypeLayoutSettingsHooks.cs new file mode 100644 index 000000000..d408c675d --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Settings/ContentTypeLayoutSettingsHooks.cs @@ -0,0 +1,23 @@ +using System.Collections.Generic; +using Orchard.ContentManagement; +using Orchard.ContentManagement.MetaData; +using Orchard.ContentManagement.MetaData.Builders; +using Orchard.ContentManagement.MetaData.Models; +using Orchard.ContentManagement.ViewModels; +using Orchard.Layouts.Helpers; + +namespace Orchard.Layouts.Settings { + public class ContentTypeLayoutSettingsHooks : ContentDefinitionEditorEventsBase { + public override IEnumerable TypeEditor(ContentTypeDefinition definition) { + var model = definition.Settings.GetModel(); + yield return DefinitionTemplate(model); + } + + public override IEnumerable TypeEditorUpdate(ContentTypeDefinitionBuilder builder, IUpdateModel updateModel) { + var model = new ContentTypeLayoutSettings(); + updateModel.TryUpdateModel(model, "ContentTypeLayoutSettings", null, null); + builder.Placeable(model.Placeable); + yield return DefinitionTemplate(model); + } + } +} \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Settings/LayoutSettingsHooks.cs b/src/Orchard.Web/Modules/Orchard.Layouts/Settings/LayoutTypePartSettingsHooks.cs similarity index 89% rename from src/Orchard.Web/Modules/Orchard.Layouts/Settings/LayoutSettingsHooks.cs rename to src/Orchard.Web/Modules/Orchard.Layouts/Settings/LayoutTypePartSettingsHooks.cs index c39e4fe42..3af598e6a 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Settings/LayoutSettingsHooks.cs +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Settings/LayoutTypePartSettingsHooks.cs @@ -8,11 +8,11 @@ using Orchard.ContentManagement.ViewModels; using Orchard.Layouts.Services; namespace Orchard.Layouts.Settings { - public class LayoutSettingsHooks : ContentDefinitionEditorEventsBase { + public class LayoutTypePartSettingsHooks : ContentDefinitionEditorEventsBase { private readonly ILayoutSerializer _serializer; private readonly ILayoutManager _layoutManager; - public LayoutSettingsHooks(ILayoutSerializer serializer, ILayoutManager layoutManager) { + public LayoutTypePartSettingsHooks(ILayoutSerializer serializer, ILayoutManager layoutManager) { _serializer = serializer; _layoutManager = layoutManager; } diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Styles/Lib.css b/src/Orchard.Web/Modules/Orchard.Layouts/Styles/Lib.css index f8d1d0be3..2280d7b76 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Styles/Lib.css +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Styles/Lib.css @@ -2614,4 +2614,4 @@ content: "\f23a"; } -/*# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["Lib.css","bootstrap.less","mixins/vendor-prefixes.less","scaffolding.less","mixins/tab-focus.less","mixins/image.less","mixins/grid.less","grid.less","mixins/grid-framework.less","mixins/clearfix.less","utilities.less","mixins/center-block.less","mixins/hide-text.less","path.less","core.less","larger.less","fixed-width.less","list.less","bordered-pulled.less","animated.less","rotated-flipped.less","mixins.less","stacked.less","icons.less"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA,ACAA;ECuEU,uBAAA;CFxET;ACCD;;ECuEU,uBAAA;CFlET;ACLD;EEiBE,gBAAA;EACA,8CAAA;CHTD;ACTD;EEsBE,4DAAA;EACA,gBAAA;EACA,wBAAA;EACA,eAAA;EACA,uBAAA;CHVD;AChBD;;;;EEkCE,qBAAA;EACA,mBAAA;EACA,qBAAA;CHZD;ACxBD;EE2CE,eAAA;EACA,sBAAA;CHhBD;AGkBC;;EAEE,eAAA;EACA,2BAAA;CHhBH;AGmBC;ECrDA,qBAAA;EAEA,2CAAA;EACA,qBAAA;CJoCD;ACtCD;EEgEE,UAAA;CHvBD;ACzCD;EEuEE,uBAAA;CH3BD;AC5CD;EIIE,eAAA;EACA,gBAAA;EACA,aAAA;CL2CD;ACjDD;EEiFE,mBAAA;CH7BD;ACpDD;EEwFE,aAAA;EACA,wBAAA;EACA,uBAAA;EACA,uBAAA;EACA,mBAAA;ED+FQ,iCAAA;EGvLR,sBAAA;EACA,gBAAA;EACA,aAAA;CL2DD;ACjED;EEqGE,mBAAA;CHjCD;ACpED;EE4GE,iBAAA;EACA,oBAAA;EACA,UAAA;EACA,8BAAA;CHrCD;AC1ED;EEwHE,mBAAA;EACA,WAAA;EACA,YAAA;EACA,aAAA;EACA,WAAA;EACA,iBAAA;EACA,uBAAA;EACA,UAAA;CH3CD;AGmDC;;EAEE,iBAAA;EACA,YAAA;EACA,aAAA;EACA,UAAA;EACA,kBAAA;EACA,WAAA;CHjDH;AC7FD;EKCE,mBAAA;EACA,kBAAA;EACA,mBAAA;EACA,oBAAA;CN+FD;AOzFC;EAqEF;IAvEI,aAAA;GP+FD;CACF;AO3FC;EAkEF;IApEI,aAAA;GPiGD;CACF;AO7FD;EA+DA;IAjEI,cAAA;GPmGD;CACF;AClHD;EKCE,mBAAA;EACA,kBAAA;EACA,mBAAA;EACA,oBAAA;CNoHD;ACxHD;EKUE,mBAAA;EACA,oBAAA;CNiHD;AC5HD;EOYM,mBAAA;EAEA,gBAAA;EAEA,mBAAA;EACA,oBAAA;CRiHL;AClID;EOkCM,YAAA;CRmGL;ACrID;EO0CI,YAAA;CR8FH;ACxID;EO0CI,oBAAA;CRiGH;AC3ID;EO0CI,oBAAA;CRoGH;AC9ID;EO0CI,WAAA;CRuGH;ACjJD;EO0CI,oBAAA;CR0GH;ACpJD;EO0CI,oBAAA;CR6GH;ACvJD;EO0CI,WAAA;CRgHH;AC1JD;EO0CI,oBAAA;CRmHH;AC7JD;EO0CI,oBAAA;CRsHH;AChKD;EO0CI,WAAA;CRyHH;ACnKD;EO0CI,oBAAA;CR4HH;ACtKD;EO0CI,mBAAA;CR+HH;ACzKD;EOyDI,YAAA;CRmHH;AC5KD;EOyDI,oBAAA;CRsHH;AC/KD;EOyDI,oBAAA;CRyHH;AClLD;EOyDI,WAAA;CR4HH;ACrLD;EOyDI,oBAAA;CR+HH;ACxLD;EOyDI,oBAAA;CRkIH;AC3LD;EOyDI,WAAA;CRqIH;AC9LD;EOyDI,oBAAA;CRwIH;ACjMD;EOyDI,oBAAA;CR2IH;ACpMD;EOyDI,WAAA;CR8IH;ACvMD;EOyDI,oBAAA;CRiJH;AC1MD;EOyDI,mBAAA;CRoJH;AC7MD;EO8DI,YAAA;CRkJH;AChND;EO+CI,WAAA;CRoKH;ACnND;EO+CI,mBAAA;CRuKH;ACtND;EO+CI,mBAAA;CR0KH;ACzND;EO+CI,UAAA;CR6KH;AC5ND;EO+CI,mBAAA;CRgLH;AC/ND;EO+CI,mBAAA;CRmLH;AClOD;EO+CI,UAAA;CRsLH;ACrOD;EO+CI,mBAAA;CRyLH;ACxOD;EO+CI,mBAAA;CR4LH;AC3OD;EO+CI,UAAA;CR+LH;AC9OD;EO+CI,mBAAA;CRkMH;ACjPD;EO+CI,kBAAA;CRqMH;ACpPD;EOoDI,WAAA;CRmMH;ACvPD;EOmEI,kBAAA;CRuLH;AC1PD;EOmEI,0BAAA;CR0LH;AC7PD;EOmEI,0BAAA;CR6LH;AChQD;EOmEI,iBAAA;CRgMH;ACnQD;EOmEI,0BAAA;CRmMH;ACtQD;EOmEI,0BAAA;CRsMH;ACzQD;EOmEI,iBAAA;CRyMH;AC5QD;EOmEI,0BAAA;CR4MH;AC/QD;EOmEI,0BAAA;CR+MH;AClRD;EOmEI,iBAAA;CRkNH;ACrRD;EOmEI,0BAAA;CRqNH;ACxRD;EOmEI,yBAAA;CRwNH;AC3RD;EOmEI,gBAAA;CR2NH;AO3ND;EAYA;IC7CM,YAAA;GRgQH;EOnNH;ICrCI,YAAA;GR2PD;EOtNH;ICrCI,oBAAA;GR8PD;EOzNH;ICrCI,oBAAA;GRiQD;EO5NH;ICrCI,WAAA;GRoQD;EO/NH;ICrCI,oBAAA;GRuQD;EOlOH;ICrCI,oBAAA;GR0QD;EOrOH;ICrCI,WAAA;GR6QD;EOxOH;ICrCI,oBAAA;GRgRD;EO3OH;ICrCI,oBAAA;GRmRD;EO9OH;ICrCI,WAAA;GRsRD;EOjPH;ICrCI,oBAAA;GRyRD;EOpPH;ICrCI,mBAAA;GR4RD;EOvPH;ICtBI,YAAA;GRgRD;EO1PH;ICtBI,oBAAA;GRmRD;EO7PH;ICtBI,oBAAA;GRsRD;EOhQH;ICtBI,WAAA;GRyRD;EOnQH;ICtBI,oBAAA;GR4RD;EOtQH;ICtBI,oBAAA;GR+RD;EOzQH;ICtBI,WAAA;GRkSD;EO5QH;ICtBI,oBAAA;GRqSD;EO/QH;ICtBI,oBAAA;GRwSD;EOlRH;ICtBI,WAAA;GR2SD;EOrRH;ICtBI,oBAAA;GR8SD;EOxRH;ICtBI,mBAAA;GRiTD;EO3RH;ICjBI,YAAA;GR+SD;EO9RH;IChCI,WAAA;GRiUD;EOjSH;IChCI,mBAAA;GRoUD;EOpSH;IChCI,mBAAA;GRuUD;EOvSH;IChCI,UAAA;GR0UD;EO1SH;IChCI,mBAAA;GR6UD;EO7SH;IChCI,mBAAA;GRgVD;EOhTH;IChCI,UAAA;GRmVD;EOnTH;IChCI,mBAAA;GRsVD;EOtTH;IChCI,mBAAA;GRyVD;EOzTH;IChCI,UAAA;GR4VD;EO5TH;IChCI,mBAAA;GR+VD;EO/TH;IChCI,kBAAA;GRkWD;EOlUH;IC3BI,WAAA;GRgWD;EOrUH;ICZI,kBAAA;GRoVD;EOxUH;ICZI,0BAAA;GRuVD;EO3UH;ICZI,0BAAA;GR0VD;EO9UH;ICZI,iBAAA;GR6VD;EOjVH;ICZI,0BAAA;GRgWD;EOpVH;ICZI,0BAAA;GRmWD;EOvVH;ICZI,iBAAA;GRsWD;EO1VH;ICZI,0BAAA;GRyWD;EO7VH;ICZI,0BAAA;GR4WD;EOhWH;ICZI,iBAAA;GR+WD;EOnWH;ICZI,0BAAA;GRkXD;EOtWH;ICZI,yBAAA;GRqXD;EOzWH;ICZI,gBAAA;GRwXD;CACF;AOhXD;EAGA;IC7CM,YAAA;GR8ZH;EOjXH;ICrCI,YAAA;GRyZD;EOpXH;ICrCI,oBAAA;GR4ZD;EOvXH;ICrCI,oBAAA;GR+ZD;EO1XH;ICrCI,WAAA;GRkaD;EO7XH;ICrCI,oBAAA;GRqaD;EOhYH;ICrCI,oBAAA;GRwaD;EOnYH;ICrCI,WAAA;GR2aD;EOtYH;ICrCI,oBAAA;GR8aD;EOzYH;ICrCI,oBAAA;GRibD;EO5YH;ICrCI,WAAA;GRobD;EO/YH;ICrCI,oBAAA;GRubD;EOlZH;ICrCI,mBAAA;GR0bD;EOrZH;ICtBI,YAAA;GR8aD;EOxZH;ICtBI,oBAAA;GRibD;EO3ZH;ICtBI,oBAAA;GRobD;EO9ZH;ICtBI,WAAA;GRubD;EOjaH;ICtBI,oBAAA;GR0bD;EOpaH;ICtBI,oBAAA;GR6bD;EOvaH;ICtBI,WAAA;GRgcD;EO1aH;ICtBI,oBAAA;GRmcD;EO7aH;ICtBI,oBAAA;GRscD;EOhbH;ICtBI,WAAA;GRycD;EOnbH;ICtBI,oBAAA;GR4cD;EOtbH;ICtBI,mBAAA;GR+cD;EOzbH;ICjBI,YAAA;GR6cD;EO5bH;IChCI,WAAA;GR+dD;EO/bH;IChCI,mBAAA;GRkeD;EOlcH;IChCI,mBAAA;GRqeD;EOrcH;IChCI,UAAA;GRweD;EOxcH;IChCI,mBAAA;GR2eD;EO3cH;IChCI,mBAAA;GR8eD;EO9cH;IChCI,UAAA;GRifD;EOjdH;IChCI,mBAAA;GRofD;EOpdH;IChCI,mBAAA;GRufD;EOvdH;IChCI,UAAA;GR0fD;EO1dH;IChCI,mBAAA;GR6fD;EO7dH;IChCI,kBAAA;GRggBD;EOheH;IC3BI,WAAA;GR8fD;EOneH;ICZI,kBAAA;GRkfD;EOteH;ICZI,0BAAA;GRqfD;EOzeH;ICZI,0BAAA;GRwfD;EO5eH;ICZI,iBAAA;GR2fD;EO/eH;ICZI,0BAAA;GR8fD;EOlfH;ICZI,0BAAA;GRigBD;EOrfH;ICZI,iBAAA;GRogBD;EOxfH;ICZI,0BAAA;GRugBD;EO3fH;ICZI,0BAAA;GR0gBD;EO9fH;ICZI,iBAAA;GR6gBD;EOjgBH;ICZI,0BAAA;GRghBD;EOpgBH;ICZI,yBAAA;GRmhBD;EOvgBH;ICZI,gBAAA;GRshBD;CACF;AO3gBD;EAAA;IC7CM,YAAA;GR4jBH;EO/gBH;ICrCI,YAAA;GRujBD;EOlhBH;ICrCI,oBAAA;GR0jBD;EOrhBH;ICrCI,oBAAA;GR6jBD;EOxhBH;ICrCI,WAAA;GRgkBD;EO3hBH;ICrCI,oBAAA;GRmkBD;EO9hBH;ICrCI,oBAAA;GRskBD;EOjiBH;ICrCI,WAAA;GRykBD;EOpiBH;ICrCI,oBAAA;GR4kBD;EOviBH;ICrCI,oBAAA;GR+kBD;EO1iBH;ICrCI,WAAA;GRklBD;EO7iBH;ICrCI,oBAAA;GRqlBD;EOhjBH;ICrCI,mBAAA;GRwlBD;EOnjBH;ICtBI,YAAA;GR4kBD;EOtjBH;ICtBI,oBAAA;GR+kBD;EOzjBH;ICtBI,oBAAA;GRklBD;EO5jBH;ICtBI,WAAA;GRqlBD;EO/jBH;ICtBI,oBAAA;GRwlBD;EOlkBH;ICtBI,oBAAA;GR2lBD;EOrkBH;ICtBI,WAAA;GR8lBD;EOxkBH;ICtBI,oBAAA;GRimBD;EO3kBH;ICtBI,oBAAA;GRomBD;EO9kBH;ICtBI,WAAA;GRumBD;EOjlBH;ICtBI,oBAAA;GR0mBD;EOplBH;ICtBI,mBAAA;GR6mBD;EOvlBH;ICjBI,YAAA;GR2mBD;EO1lBH;IChCI,WAAA;GR6nBD;EO7lBH;IChCI,mBAAA;GRgoBD;EOhmBH;IChCI,mBAAA;GRmoBD;EOnmBH;IChCI,UAAA;GRsoBD;EOtmBH;IChCI,mBAAA;GRyoBD;EOzmBH;IChCI,mBAAA;GR4oBD;EO5mBH;IChCI,UAAA;GR+oBD;EO/mBH;IChCI,mBAAA;GRkpBD;EOlnBH;IChCI,mBAAA;GRqpBD;EOrnBH;IChCI,UAAA;GRwpBD;EOxnBH;IChCI,mBAAA;GR2pBD;EO3nBH;IChCI,kBAAA;GR8pBD;EO9nBH;IC3BI,WAAA;GR4pBD;EOjoBH;ICZI,kBAAA;GRgpBD;EOpoBH;ICZI,0BAAA;GRmpBD;EOvoBH;ICZI,0BAAA;GRspBD;EO1oBH;ICZI,iBAAA;GRypBD;EO7oBH;ICZI,0BAAA;GR4pBD;EOhpBH;ICZI,0BAAA;GR+pBD;EOnpBH;ICZI,iBAAA;GRkqBD;EOtpBH;ICZI,0BAAA;GRqqBD;EOzpBH;ICZI,0BAAA;GRwqBD;EO5pBH;ICZI,iBAAA;GR2qBD;EO/pBH;ICZI,0BAAA;GR8qBD;EOlqBH;ICZI,yBAAA;GRirBD;EOrqBH;ICZI,gBAAA;GRorBD;CACF;AShvBC;;;;;;;;EAEE,aAAA;EACA,eAAA;CTwvBH;AStvBC;;;;EACE,YAAA;CT2vBH;AUnwBD;ECRE,eAAA;EACA,kBAAA;EACA,mBAAA;CX8wBD;AUrwBD;EACE,wBAAA;CVuwBD;AUrwBD;EACE,uBAAA;CVuwBD;AU/vBD;EACE,yBAAA;CViwBD;AU/vBD;EACE,0BAAA;CViwBD;AU/vBD;EACE,mBAAA;CViwBD;AU/vBD;EEzBE,YAAA;EACA,mBAAA;EACA,kBAAA;EACA,8BAAA;EACA,UAAA;CZ2xBD;AU7vBD;EACE,yBAAA;EACA,8BAAA;CV+vBD;AUxvBD;EACE,gBAAA;CV0vBD;;AAED;;;GAGG;AACH;gCACgC;AapzBhC;EACE,2BAAA;EACA,kDAAA;EACA,mWAAA;EAMA,oBAAA;EACA,mBAAA;CbizBD;Ac3zBD;EACE,sBAAA;EACA,8CAAA;EACA,mBAAA;EACA,qBAAA;EACA,oCAAA;EACA,mCAAA;EACA,mCAAA;UAAA,2BAAA;Cd6zBD;AACD,8DAA8D;Aep0B9D;EACE,wBAAA;EACA,oBAAA;EACA,qBAAA;Cfs0BD;Aep0BD;EAAuB,eAAA;Cfu0BtB;Aet0BD;EAAuB,eAAA;Cfy0BtB;Aex0BD;EAAuB,eAAA;Cf20BtB;Ae10BD;EAAuB,eAAA;Cf60BtB;AgBv1BD;EACE,oBAAA;EACA,mBAAA;ChBy1BD;AiB11BD;EACE,gBAAA;EACA,0BAAA;EACA,sBAAA;CjB41BD;AiB/1BD;EAIS,mBAAA;CjB81BR;AiB51BD;EACE,mBAAA;EACA,oBAAA;EACA,oBAAA;EACA,kBAAA;EACA,mBAAA;CjB81BD;AiB71BC;EACE,oBAAA;CjB+1BH;AkB52BD;EACE,0BAAA;EACA,0BAAA;EACA,oBAAA;ClB82BD;AkB32BD;EAAc,aAAA;ClB82Bb;AkB72BD;EAAa,YAAA;ClBg3BZ;AkB72BC;EAAc,mBAAA;ClBg3Bf;AkB/2BC;EAAe,kBAAA;ClBk3BhB;AmB73BD;EACE,8CAAA;EACQ,sCAAA;CnB+3BT;AmB53BD;EACE,gDAAA;EACQ,wCAAA;CnB83BT;AmB33BD;EACE;IACE,gCAAA;IACQ,wBAAA;GnB63BT;EmB33BD;IACE,kCAAA;IACQ,0BAAA;GnB63BT;CACF;AmB13BD;EACE;IACE,gCAAA;IACQ,wBAAA;GnB43BT;EmB13BD;IACE,kCAAA;IACQ,0BAAA;GnB43BT;CACF;AoBz5BD;ECYE,iEAAA;EACA,iCAAA;EAEQ,yBAAA;CrBg5BT;AoB95BD;ECWE,iEAAA;EACA,kCAAA;EAEQ,0BAAA;CrBs5BT;AoBn6BD;ECUE,iEAAA;EACA,kCAAA;EAEQ,0BAAA;CrB45BT;AoBv6BD;ECeE,2EAAA;EACA,gCAAA;EAEQ,wBAAA;CrB25BT;AoB56BD;ECcE,2EAAA;EACA,gCAAA;EAEQ,wBAAA;CrBi6BT;AoB76BD;;;;;EAKE,qBAAA;UAAA,aAAA;CpB+6BD;AsB97BD;EACE,mBAAA;EACA,sBAAA;EACA,WAAA;EACA,YAAA;EACA,iBAAA;EACA,uBAAA;CtBg8BD;AsB97BD;;EACE,mBAAA;EACA,QAAA;EACA,YAAA;EACA,mBAAA;CtBi8BD;AsB/7BD;EAA6B,qBAAA;CtBk8B5B;AsBj8BD;EAA6B,eAAA;CtBo8B5B;AsBn8BD;EAA4B,YAAA;CtBs8B3B;AACD;oEACoE;AuBx9BpE;EAAiC,iBAAA;CvB29BhC;AuB19BD;EAAiC,iBAAA;CvB69BhC;AuB59BD;EAAkC,iBAAA;CvB+9BjC;AuB99BD;EAAsC,iBAAA;CvBi+BrC;AuBh+BD;EAAiC,iBAAA;CvBm+BhC;AuBl+BD;EAAgC,iBAAA;CvBq+B/B;AuBp+BD;EAAkC,iBAAA;CvBu+BjC;AuBt+BD;EAAgC,iBAAA;CvBy+B/B;AuBx+BD;EAAgC,iBAAA;CvB2+B/B;AuB1+BD;EAAoC,iBAAA;CvB6+BnC;AuB5+BD;EAA8B,iBAAA;CvB++B7B;AuB9+BD;EAAmC,iBAAA;CvBi/BlC;AuBh/BD;EAAiC,iBAAA;CvBm/BhC;AuBl/BD;;;EAEiC,iBAAA;CvBq/BhC;AuBp/BD;EAAuC,iBAAA;CvBu/BtC;AuBt/BD;EAAwC,iBAAA;CvBy/BvC;AuBx/BD;EAAqC,iBAAA;CvB2/BpC;AuB1/BD;EAAkC,iBAAA;CvB6/BjC;AuB5/BD;;EAC+B,iBAAA;CvB+/B9B;AuB9/BD;EAAmC,iBAAA;CvBigClC;AuBhgCD;EAAgC,iBAAA;CvBmgC/B;AuBlgCD;EAAkC,iBAAA;CvBqgCjC;AuBpgCD;EAAmC,iBAAA;CvBugClC;AuBtgCD;EAAgC,iBAAA;CvBygC/B;AuBxgCD;EAAoC,iBAAA;CvB2gCnC;AuB1gCD;EAA+C,iBAAA;CvB6gC9C;AuB5gCD;EAA6C,iBAAA;CvB+gC5C;AuB9gCD;EAAiC,iBAAA;CvBihChC;AuBhhCD;EAAyC,iBAAA;CvBmhCxC;AuBlhCD;;EACkC,iBAAA;CvBqhCjC;AuBphCD;EAAmC,iBAAA;CvBuhClC;AuBthCD;EAAoC,iBAAA;CvByhCnC;AuBxhCD;EAAgC,iBAAA;CvB2hC/B;AuB1hCD;EAAgC,iBAAA;CvB6hC/B;AuB5hCD;EAAsC,iBAAA;CvB+hCrC;AuB9hCD;EAAsC,iBAAA;CvBiiCrC;AuBhiCD;EAAuC,iBAAA;CvBmiCtC;AuBliCD;EAAqC,iBAAA;CvBqiCpC;AuBpiCD;EAAkC,iBAAA;CvBuiCjC;AuBtiCD;EAAmC,iBAAA;CvByiClC;AuBxiCD;EAA+B,iBAAA;CvB2iC9B;AuB1iCD;EAAgC,iBAAA;CvB6iC/B;AuB5iCD;EAAgC,iBAAA;CvB+iC/B;AuB9iCD;EAAoC,iBAAA;CvBijCnC;AuBhjCD;EAAiC,iBAAA;CvBmjChC;AuBljCD;EAAkC,iBAAA;CvBqjCjC;AuBpjCD;EAAgC,iBAAA;CvBujC/B;AuBtjCD;EAAgC,iBAAA;CvByjC/B;AuBxjCD;EAAkC,iBAAA;CvB2jCjC;AuB1jCD;EAAuC,iBAAA;CvB6jCtC;AuB5jCD;EAAsC,iBAAA;CvB+jCrC;AuB9jCD;EAAsC,iBAAA;CvBikCrC;AuBhkCD;EAAwC,iBAAA;CvBmkCvC;AuBlkCD;EAAuC,iBAAA;CvBqkCtC;AuBpkCD;EAAyC,iBAAA;CvBukCxC;AuBtkCD;EAAgC,iBAAA;CvBykC/B;AuBxkCD;;EACmC,iBAAA;CvB2kClC;AuB1kCD;EAAkC,iBAAA;CvB6kCjC;AuB5kCD;EAAwC,iBAAA;CvB+kCvC;AuB9kCD;;;EAEqC,iBAAA;CvBilCpC;AuBhlCD;EAAkC,iBAAA;CvBmlCjC;AuBllCD;EAAsC,iBAAA;CvBqlCrC;AuBplCD;EAAkC,iBAAA;CvBulCjC;AuBtlCD;EAAgC,iBAAA;CvBylC/B;AuBxlCD;;EAC2C,iBAAA;CvB2lC1C;AuB1lCD;EAA0C,iBAAA;CvB6lCzC;AuB5lCD;EAA0C,iBAAA;CvB+lCzC;AuB9lCD;EAAkC,iBAAA;CvBimCjC;AuBhmCD;EAAyC,iBAAA;CvBmmCxC;AuBlmCD;EAAyC,iBAAA;CvBqmCxC;AuBpmCD;EAAoC,iBAAA;CvBumCnC;AuBtmCD;EAAgC,iBAAA;CvBymC/B;AuBxmCD;EAAiC,iBAAA;CvB2mChC;AuB1mCD;EAAgC,iBAAA;CvB6mC/B;AuB5mCD;EAAmC,iBAAA;CvB+mClC;AuB9mCD;EAAwC,iBAAA;CvBinCvC;AuBhnCD;EAAwC,iBAAA;CvBmnCvC;AuBlnCD;EAAiC,iBAAA;CvBqnChC;AuBpnCD;EAAwC,iBAAA;CvBunCvC;AuBtnCD;EAAyC,iBAAA;CvBynCxC;AuBxnCD;EAAuC,iBAAA;CvB2nCtC;AuB1nCD;EAAwC,iBAAA;CvB6nCvC;AuB5nCD;EAAwC,iBAAA;CvB+nCvC;AuB9nCD;EAAwC,iBAAA;CvBioCvC;AuBhoCD;EAA2C,iBAAA;CvBmoC1C;AuBloCD;EAAuC,iBAAA;CvBqoCtC;AuBpoCD;EAAsC,iBAAA;CvBuoCrC;AuBtoCD;EAA0C,iBAAA;CvByoCzC;AuBxoCD;EAA0C,iBAAA;CvB2oCzC;AuB1oCD;EAA+B,iBAAA;CvB6oC9B;AuB5oCD;EAAsC,iBAAA;CvB+oCrC;AuB9oCD;EAAuC,iBAAA;CvBipCtC;AuBhpCD;EAAoC,iBAAA;CvBmpCnC;AuBlpCD;EAAsC,iBAAA;CvBqpCrC;AuBppCD;;EACiC,iBAAA;CvBupChC;AuBtpCD;EAAkC,iBAAA;CvBypCjC;AuBxpCD;EAAoC,iBAAA;CvB2pCnC;AuB1pCD;EAAgC,iBAAA;CvB6pC/B;AuB5pCD;EAAiC,iBAAA;CvB+pChC;AuB9pCD;EAAoC,iBAAA;CvBiqCnC;AuBhqCD;EAA8C,iBAAA;CvBmqC7C;AuBlqCD;EAAgC,iBAAA;CvBqqC/B;AuBpqCD;EAAgC,iBAAA;CvBuqC/B;AuBtqCD;EAAgC,iBAAA;CvByqC/B;AuBxqCD;EAA+B,iBAAA;CvB2qC9B;AuB1qCD;EAAqC,iBAAA;CvB6qCpC;AuB5qCD;;EACgD,iBAAA;CvB+qC/C;AuB9qCD;EAAiC,iBAAA;CvBirChC;AuBhrCD;EAAoC,iBAAA;CvBmrCnC;AuBlrCD;EAAkC,iBAAA;CvBqrCjC;AuBprCD;EAAmC,iBAAA;CvBurClC;AuBtrCD;EAAkC,iBAAA;CvByrCjC;AuBxrCD;EAAsC,iBAAA;CvB2rCrC;AuB1rCD;EAAwC,iBAAA;CvB6rCvC;AuB5rCD;EAAmC,iBAAA;CvB+rClC;AuB9rCD;EAAyC,iBAAA;CvBisCxC;AuBhsCD;EAAkC,iBAAA;CvBmsCjC;AuBlsCD;EAAuC,iBAAA;CvBqsCtC;AuBpsCD;EAAoC,iBAAA;CvBusCnC;AuBtsCD;EAAoC,iBAAA;CvBysCnC;AuBxsCD;;EACqC,iBAAA;CvB2sCpC;AuB1sCD;EAA0C,iBAAA;CvB6sCzC;AuB5sCD;EAA2C,iBAAA;CvB+sC1C;AuB9sCD;EAAwC,iBAAA;CvBitCvC;AuBhtCD;EAA+B,iBAAA;CvBmtC9B;AuBltCD;;EACgC,iBAAA;CvBqtC/B;AuBptCD;EAAoC,iBAAA;CvButCnC;AuBttCD;EAAuC,iBAAA;CvBytCtC;AuBxtCD;EAAyC,iBAAA;CvB2tCxC;AuB1tCD;EAAqC,iBAAA;CvB6tCpC;AuB5tCD;EAAmC,iBAAA;CvB+tClC;AuB9tCD;EAAoC,iBAAA;CvBiuCnC;AuBhuCD;EAA2C,iBAAA;CvBmuC1C;AuBluCD;EAAsC,iBAAA;CvBquCrC;AuBpuCD;EAAyC,iBAAA;CvBuuCxC;AuBtuCD;EAAmC,iBAAA;CvByuClC;AuBxuCD;EAAkC,iBAAA;CvB2uCjC;AuB1uCD;EAAyC,iBAAA;CvB6uCxC;AuB5uCD;EAAkC,iBAAA;CvB+uCjC;AuB9uCD;EAAmC,iBAAA;CvBivClC;AuBhvCD;EAAiC,iBAAA;CvBmvChC;AuBlvCD;EAAoC,iBAAA;CvBqvCnC;AuBpvCD;EAAsC,iBAAA;CvBuvCrC;AuBtvCD;EAAwC,iBAAA;CvByvCvC;AuBxvCD;EAAmC,iBAAA;CvB2vClC;AuB1vCD;;EACoC,iBAAA;CvB6vCnC;AuB5vCD;EAAkC,iBAAA;CvB+vCjC;AuB9vCD;EAAkC,iBAAA;CvBiwCjC;AuBhwCD;EAAuC,iBAAA;CvBmwCtC;AuBlwCD;EAA+B,iBAAA;CvBqwC9B;AuBpwCD;EAAiC,iBAAA;CvBuwChC;AuBtwCD;EAAoC,iBAAA;CvBywCnC;AuBxwCD;EAAgC,iBAAA;CvB2wC/B;AuB1wCD;EAAuC,iBAAA;CvB6wCtC;AuB5wCD;EAAwC,iBAAA;CvB+wCvC;AuB9wCD;EAAuC,iBAAA;CvBixCtC;AuBhxCD;EAAqC,iBAAA;CvBmxCpC;AuBlxCD;EAAuC,iBAAA;CvBqxCtC;AuBpxCD;EAA6C,iBAAA;CvBuxC5C;AuBtxCD;EAA8C,iBAAA;CvByxC7C;AuBxxCD;EAA2C,iBAAA;CvB2xC1C;AuB1xCD;EAA6C,iBAAA;CvB6xC5C;AuB5xCD;EAAiC,iBAAA;CvB+xChC;AuB9xCD;EAAkC,iBAAA;CvBiyCjC;AuBhyCD;EAAiC,iBAAA;CvBmyChC;AuBlyCD;EAAkC,iBAAA;CvBqyCjC;AuBpyCD;EAAqC,iBAAA;CvBuyCpC;AuBtyCD;EAAsC,iBAAA;CvByyCrC;AuBxyCD;;EACiC,iBAAA;CvB2yChC;AuB1yCD;;EACgC,iBAAA;CvB6yC/B;AuB5yCD;EAAiC,iBAAA;CvB+yChC;AuB9yCD;EAAiC,iBAAA;CvBizChC;AuBhzCD;;EACoC,iBAAA;CvBmzCnC;AuBlzCD;;EACmC,iBAAA;CvBqzClC;AuBpzCD;EAAqC,iBAAA;CvBuzCpC;AuBtzCD;;EACoC,iBAAA;CvByzCnC;AuBxzCD;EAAkC,iBAAA;CvB2zCjC;AuB1zCD;;;EAEgC,iBAAA;CvB6zC/B;AuB5zCD;EAAmC,iBAAA;CvB+zClC;AuB9zCD;EAAmC,iBAAA;CvBi0ClC;AuBh0CD;EAAyC,iBAAA;CvBm0CxC;AuBl0CD;EAAqC,iBAAA;CvBq0CpC;AuBp0CD;EAAiC,iBAAA;CvBu0ChC;AuBt0CD;EAAiC,iBAAA;CvBy0ChC;AuBx0CD;EAAiC,iBAAA;CvB20ChC;AuB10CD;EAAqC,iBAAA;CvB60CpC;AuB50CD;EAA4C,iBAAA;CvB+0C3C;AuB90CD;EAA8C,iBAAA;CvBi1C7C;AuBh1CD;EAAuC,iBAAA;CvBm1CtC;AuBl1CD;EAAiC,iBAAA;CvBq1ChC;AuBp1CD;EAAsC,iBAAA;CvBu1CrC;AuBt1CD;EAAoC,iBAAA;CvBy1CnC;AuBx1CD;EAAsC,iBAAA;CvB21CrC;AuB11CD;EAAuC,iBAAA;CvB61CtC;AuB51CD;EAAmC,iBAAA;CvB+1ClC;AuB91CD;;EACgC,iBAAA;CvBi2C/B;AuBh2CD;;EACqC,iBAAA;CvBm2CpC;AuBl2CD;;EACoC,iBAAA;CvBq2CnC;AuBp2CD;EAAoC,iBAAA;CvBu2CnC;AuBt2CD;EAAoC,iBAAA;CvBy2CnC;AuBx2CD;;EACgC,iBAAA;CvB22C/B;AuB12CD;;EACiC,iBAAA;CvB62ChC;AuB52CD;;EACsC,iBAAA;CvB+2CrC;AuB92CD;EAAqC,iBAAA;CvBi3CpC;AuBh3CD;EAAsC,iBAAA;CvBm3CrC;AuBl3CD;;EACgC,iBAAA;CvBq3C/B;AuBp3CD;EAAmC,iBAAA;CvBu3ClC;AuBt3CD;EAAoC,iBAAA;CvBy3CnC;AuBx3CD;;EACqC,iBAAA;CvB23CpC;AuB13CD;EAAuC,iBAAA;CvB63CtC;AuB53CD;EAAoC,iBAAA;CvB+3CnC;AuB93CD;EAA0C,iBAAA;CvBi4CzC;AuBh4CD;EAAwC,iBAAA;CvBm4CvC;AuBl4CD;EAAmC,iBAAA;CvBq4ClC;AuBp4CD;EAAuC,iBAAA;CvBu4CtC;AuBt4CD;EAAoC,iBAAA;CvBy4CnC;AuBx4CD;EAAkC,iBAAA;CvB24CjC;AuB14CD;EAAkC,iBAAA;CvB64CjC;AuB54CD;EAAmC,iBAAA;CvB+4ClC;AuB94CD;EAAuC,iBAAA;CvBi5CtC;AuBh5CD;EAAsC,iBAAA;CvBm5CrC;AuBl5CD;EAAsC,iBAAA;CvBq5CrC;AuBp5CD;EAAqC,iBAAA;CvBu5CpC;AuBt5CD;EAAkC,iBAAA;CvBy5CjC;AuBx5CD;EAAuC,iBAAA;CvB25CtC;AuB15CD;EAAgC,iBAAA;CvB65C/B;AuB55CD;EAAoC,iBAAA;CvB+5CnC;AuB95CD;EAAuC,iBAAA;CvBi6CtC;AuBh6CD;EAA6C,iBAAA;CvBm6C5C;AuBl6CD;EAA8C,iBAAA;CvBq6C7C;AuBp6CD;EAA2C,iBAAA;CvBu6C1C;AuBt6CD;EAA6C,iBAAA;CvBy6C5C;AuBx6CD;EAAsC,iBAAA;CvB26CrC;AuB16CD;EAAuC,iBAAA;CvB66CtC;AuB56CD;EAAoC,iBAAA;CvB+6CnC;AuB96CD;EAAsC,iBAAA;CvBi7CrC;AuBh7CD;EAAmC,iBAAA;CvBm7ClC;AuBl7CD;EAAkC,iBAAA;CvBq7CjC;AuBp7CD;EAAkC,iBAAA;CvBu7CjC;AuBt7CD;;EACkC,iBAAA;CvBy7CjC;AuBx7CD;EAAoC,iBAAA;CvB27CnC;AuB17CD;EAAsC,iBAAA;CvB67CrC;AuB57CD;EAAuC,iBAAA;CvB+7CtC;AuB97CD;EAAmC,iBAAA;CvBi8ClC;AuBh8CD;EAAkC,iBAAA;CvBm8CjC;AuBl8CD;;EACiC,iBAAA;CvBq8ChC;AuBp8CD;EAAsC,iBAAA;CvBu8CrC;AuBt8CD;EAAoC,iBAAA;CvBy8CnC;AuBx8CD;EAAyC,iBAAA;CvB28CxC;AuB18CD;EAAmC,iBAAA;CvB68ClC;AuB58CD;EAAmC,iBAAA;CvB+8ClC;AuB98CD;EAAiC,iBAAA;CvBi9ChC;AuBh9CD;EAAmC,iBAAA;CvBm9ClC;AuBl9CD;EAAsC,iBAAA;CvBq9CrC;AuBp9CD;EAAkC,iBAAA;CvBu9CjC;AuBt9CD;EAA0C,iBAAA;CvBy9CzC;AuBx9CD;EAAoC,iBAAA;CvB29CnC;AuB19CD;EAAgC,iBAAA;CvB69C/B;AuB59CD;;EACqC,iBAAA;CvB+9CpC;AuB99CD;;;EAEuC,iBAAA;CvBi+CtC;AuBh+CD;EAA0C,iBAAA;CvBm+CzC;AuBl+CD;EAAgC,iBAAA;CvBq+C/B;AuBp+CD;EAAqC,iBAAA;CvBu+CpC;AuBt+CD;;EACwC,iBAAA;CvBy+CvC;AuBx+CD;EAAoC,iBAAA;CvB2+CnC;AuB1+CD;EAAgC,iBAAA;CvB6+C/B;AuB5+CD;EAAuC,iBAAA;CvB++CtC;AuB9+CD;EAAuC,iBAAA;CvBi/CtC;AuBh/CD;EAAqC,iBAAA;CvBm/CpC;AuBl/CD;EAAkC,iBAAA;CvBq/CjC;AuBp/CD;EAAwC,iBAAA;CvBu/CvC;AuBt/CD;EAAsC,iBAAA;CvBy/CrC;AuBx/CD;EAA4C,iBAAA;CvB2/C3C;AuB1/CD;EAAkC,iBAAA;CvB6/CjC;AuB5/CD;EAAsC,iBAAA;CvB+/CrC;AuB9/CD;EAA6C,iBAAA;CvBigD5C;AuBhgDD;EAAkC,iBAAA;CvBmgDjC;AuBlgDD;EAAkC,iBAAA;CvBqgDjC;AuBpgDD;EAA+C,iBAAA;CvBugD9C;AuBtgDD;EAAgD,iBAAA;CvBygD/C;AuBxgDD;EAA6C,iBAAA;CvB2gD5C;AuB1gDD;EAA+C,iBAAA;CvB6gD9C;AuB5gDD;EAAiC,iBAAA;CvB+gDhC;AuB9gDD;EAAgC,iBAAA;CvBihD/B;AuBhhDD;EAAkC,iBAAA;CvBmhDjC;AuBlhDD;EAAsC,iBAAA;CvBqhDrC;AuBphDD;EAAoC,iBAAA;CvBuhDnC;AuBthDD;EAAsC,iBAAA;CvByhDrC;AuBxhDD;EAAsC,iBAAA;CvB2hDrC;AuB1hDD;EAAsC,iBAAA;CvB6hDrC;AuB5hDD;EAAuC,iBAAA;CvB+hDtC;AuB9hDD;EAAkC,iBAAA;CvBiiDjC;AuBhiDD;EAAwC,iBAAA;CvBmiDvC;AuBliDD;EAA0C,iBAAA;CvBqiDzC;AuBpiDD;EAAoC,iBAAA;CvBuiDnC;AuBtiDD;EAAsC,iBAAA;CvByiDrC;AuBxiDD;EAAwC,iBAAA;CvB2iDvC;AuB1iDD;EAAyC,iBAAA;CvB6iDxC;AuB5iDD;EAAgD,iBAAA;CvB+iD/C;AuB9iDD;EAAwC,iBAAA;CvBijDvC;AuBhjDD;EAAmC,iBAAA;CvBmjDlC;AuBljDD;;EAC+C,iBAAA;CvBqjD9C;AuBpjDD;;EAC6C,iBAAA;CvBujD5C;AuBtjDD;;EACgD,iBAAA;CvByjD/C;AuBxjDD;;EAC+B,iBAAA;CvB2jD9B;AuB1jDD;EAA+B,iBAAA;CvB6jD9B;AuB5jDD;;EAC+B,iBAAA;CvB+jD9B;AuB9jDD;;EAC+B,iBAAA;CvBikD9B;AuBhkDD;;;;EAG+B,iBAAA;CvBmkD9B;AuBlkDD;;;EAE+B,iBAAA;CvBqkD9B;AuBpkDD;;EAC+B,iBAAA;CvBukD9B;AuBtkDD;;EAC+B,iBAAA;CvBykD9B;AuBxkDD;EAAgC,iBAAA;CvB2kD/B;AuB1kDD;EAAqC,iBAAA;CvB6kDpC;AuB5kDD;EAA0C,iBAAA;CvB+kDzC;AuB9kDD;EAA2C,iBAAA;CvBilD1C;AuBhlDD;EAA2C,iBAAA;CvBmlD1C;AuBllDD;EAA4C,iBAAA;CvBqlD3C;AuBplDD;EAA4C,iBAAA;CvBulD3C;AuBtlDD;EAA6C,iBAAA;CvBylD5C;AuBxlDD;EAAqC,iBAAA;CvB2lDpC;AuB1lDD;EAAuC,iBAAA;CvB6lDtC;AuB5lDD;EAA0C,iBAAA;CvB+lDzC;AuB9lDD;EAAmC,iBAAA;CvBimDlC;AuBhmDD;EAAgC,iBAAA;CvBmmD/B;AuBlmDD;EAAuC,iBAAA;CvBqmDtC;AuBpmDD;EAAwC,iBAAA;CvBumDvC;AuBtmDD;EAAmC,iBAAA;CvBymDlC;AuBxmDD;EAA0C,iBAAA;CvB2mDzC;AuB1mDD;EAAqC,iBAAA;CvB6mDpC;AuB5mDD;EAAkC,iBAAA;CvB+mDjC;AuB9mDD;EAA+B,iBAAA;CvBinD9B;AuBhnDD;EAAqC,iBAAA;CvBmnDpC;AuBlnDD;EAA4C,iBAAA;CvBqnD3C;AuBpnDD;EAAkC,iBAAA;CvBunDjC;AuBtnDD;EAAyC,iBAAA;CvBynDxC;AuBxnDD;EAA2C,iBAAA;CvB2nD1C;AuB1nDD;EAAyC,iBAAA;CvB6nDxC;AuB5nDD;EAA2C,iBAAA;CvB+nD1C;AuB9nDD;EAA4C,iBAAA;CvBioD3C;AuBhoDD;EAAiC,iBAAA;CvBmoDhC;AuBloDD;EAAmC,iBAAA;CvBqoDlC;AuBpoDD;EAAmC,iBAAA;CvBuoDlC;AuBtoDD;EAAiC,iBAAA;CvByoDhC;AuBxoDD;EAAoC,iBAAA;CvB2oDnC;AuB1oDD;EAAiC,iBAAA;CvB6oDhC;AuB5oDD;EAAsC,iBAAA;CvB+oDrC;AuB9oDD;EAAkC,iBAAA;CvBipDjC;AuBhpDD;EAAkC,iBAAA;CvBmpDjC;AuBlpDD;EAAgC,iBAAA;CvBqpD/B;AuBppDD;;EACoC,iBAAA;CvBupDnC;AuBtpDD;EAAiC,iBAAA;CvBypDhC;AuBxpDD;EAAkC,iBAAA;CvB2pDjC;AuB1pDD;EAAmC,iBAAA;CvB6pDlC;AuB5pDD;EAA+B,iBAAA;CvB+pD9B;AuB9pDD;EAA8B,iBAAA;CvBiqD7B;AuBhqDD;EAAiC,iBAAA;CvBmqDhC;AuBlqDD;EAAkC,iBAAA;CvBqqDjC;AuBpqDD;EAAqC,iBAAA;CvBuqDpC;AuBtqDD;EAA0C,iBAAA;CvByqDzC;AuBxqDD;EAAgD,iBAAA;CvB2qD/C;AuB1qDD;EAA+C,iBAAA;CvB6qD9C;AuB5qDD;;EAC+C,iBAAA;CvB+qD9C;AuB9qDD;EAAwC,iBAAA;CvBirDvC;AuBhrDD;EAAsC,iBAAA;CvBmrDrC;AuBlrDD;EAAwC,iBAAA;CvBqrDvC;AuBprDD;;EAC+B,iBAAA;CvBurD9B;AuBtrDD;EAAyC,iBAAA;CvByrDxC;AuBxrDD;EAAyC,iBAAA;CvB2rDxC;AuB1rDD;EAAiC,iBAAA;CvB6rDhC;AuB5rDD;EAA2C,iBAAA;CvB+rD1C;AuB9rDD;EAAqC,iBAAA;CvBisDpC;AuBhsDD;EAAkC,iBAAA;CvBmsDjC;AuBlsDD;;;EAEsC,iBAAA;CvBqsDrC;AuBpsDD;;EAC0C,iBAAA;CvBusDzC;AuBtsDD;EAAiC,iBAAA;CvBysDhC;AuBxsDD;EAAkC,iBAAA;CvB2sDjC;AuB1sDD;EAAkC,iBAAA;CvB6sDjC;AuB5sDD;EAAyC,iBAAA;CvB+sDxC;AuB9sDD;EAA8C,iBAAA;CvBitD7C;AuBhtDD;EAAuC,iBAAA;CvBmtDtC;AuBltDD;EAAqC,iBAAA;CvBqtDpC;AuBptDD;EAAgC,iBAAA;CvButD/B;AuBttDD;EAAsC,iBAAA;CvBytDrC;AuBxtDD;EAA0C,iBAAA;CvB2tDzC;AuB1tDD;EAAkC,iBAAA;CvB6tDjC;AuB5tDD;EAAkC,iBAAA;CvB+tDjC;AuB9tDD;EAAoC,iBAAA;CvBiuDnC;AuBhuDD;EAA+B,iBAAA;CvBmuD9B;AuBluDD;EAAoC,iBAAA;CvBquDnC;AuBpuDD;EAAiC,iBAAA;CvBuuDhC;AuBtuDD;EAA+B,iBAAA;CvByuD9B;AuBxuDD;EAAiC,iBAAA;CvB2uDhC;AuB1uDD;EAAgC,iBAAA;CvB6uD/B;AuB5uDD;EAAiC,iBAAA;CvB+uDhC;AuB9uDD;EAAmC,iBAAA;CvBivDlC;AuBhvDD;EAA0C,iBAAA;CvBmvDzC;AuBlvDD;EAAiC,iBAAA;CvBqvDhC;AuBpvDD;EAAwC,iBAAA;CvBuvDvC;AuBtvDD;EAAmC,iBAAA;CvByvDlC;AuBxvDD;;EAC+B,iBAAA;CvB2vD9B;AuB1vDD;;EACgC,iBAAA;CvB6vD/B;AuB5vDD;EAAgC,iBAAA;CvB+vD/B;AuB9vDD;EAAmC,iBAAA;CvBiwDlC;AuBhwDD;EAAsC,iBAAA;CvBmwDrC;AuBlwDD;EAAsC,iBAAA;CvBqwDrC;AuBpwDD;EAAoC,iBAAA;CvBuwDnC;AuBtwDD;EAAsC,iBAAA;CvBywDrC;AuBxwDD;EAAuC,iBAAA;CvB2wDtC;AuB1wDD;EAAwC,iBAAA;CvB6wDvC;AuB5wDD;EAA6C,iBAAA;CvB+wD5C;AuB9wDD;;;EAEwC,iBAAA;CvBixDvC;AuBhxDD;;EAC0C,iBAAA;CvBmxDzC;AuBlxDD;;EACwC,iBAAA;CvBqxDvC;AuBpxDD;;EACwC,iBAAA;CvBuxDvC;AuBtxDD;EAAuC,iBAAA;CvByxDtC;AuBxxDD;EAAgC,iBAAA;CvB2xD/B;AuB1xDD;EAAmC,iBAAA;CvB6xDlC;AuB5xDD;EAAoC,iBAAA;CvB+xDnC;AuB9xDD;;;;;EAIqC,iBAAA;CvBiyDpC;AuBhyDD;EAA0C,iBAAA;CvBmyDzC;AuBlyDD;;EACiC,iBAAA;CvBqyDhC;AuBpyDD;;EACkC,iBAAA;CvBuyDjC;AuBtyDD;EAAsC,iBAAA;CvByyDrC;AuBxyDD;EAA+B,iBAAA;CvB2yD9B;AuB1yDD;EAAuC,iBAAA;CvB6yDtC;AuB5yDD;EAAyC,iBAAA;CvB+yDxC;AuB9yDD;EAA8B,iBAAA;CvBizD7B;AuBhzDD;;EACkC,iBAAA;CvBmzDjC;AuBlzDD;;EACuC,iBAAA;CvBqzDtC;AuBpzDD;;EACyC,iBAAA;CvBuzDxC;AuBtzDD;EAAmC,iBAAA;CvByzDlC;AuBxzDD;;EACuC,iBAAA;CvB2zDtC;AuB1zDD;EAAkC,iBAAA;CvB6zDjC;AuB5zDD;EAAqC,iBAAA;CvB+zDpC;AuB9zDD;EAAmC,iBAAA;CvBi0DlC;AuBh0DD;EAAqC,iBAAA;CvBm0DpC;AuBl0DD;EAA4C,iBAAA;CvBq0D3C;AuBp0DD;EAAgC,iBAAA;CvBu0D/B;AuBt0DD;;EACoC,iBAAA;CvBy0DnC;AuBx0DD;EAA+B,iBAAA;CvB20D9B;AuB10DD;EAAsC,iBAAA;CvB60DrC;AuB50DD;EAAgC,iBAAA;CvB+0D/B;AuB90DD;EAAsC,iBAAA;CvBi1DrC;AuBh1DD;EAAkC,iBAAA;CvBm1DjC;AuBl1DD;EAAgC,iBAAA;CvBq1D/B;AuBp1DD;EAAuC,iBAAA;CvBu1DtC;AuBt1DD;EAAgC,iBAAA;CvBy1D/B;AuBx1DD;EAAsC,iBAAA;CvB21DrC;AuB11DD;EAAkC,iBAAA;CvB61DjC;AuB51DD;EAAyC,iBAAA;CvB+1DxC;AuB91DD;EAAmC,iBAAA;CvBi2DlC;AuBh2DD;EAAyC,iBAAA;CvBm2DxC;AuBl2DD;EAAuC,iBAAA;CvBq2DtC;AuBp2DD;EAAmC,iBAAA;CvBu2DlC;AuBt2DD;EAAqC,iBAAA;CvBy2DpC;AuBx2DD;EAAqC,iBAAA;CvB22DpC;AuB12DD;EAAsC,iBAAA;CvB62DrC;AuB52DD;EAAwC,iBAAA;CvB+2DvC;AuB92DD;EAAiC,iBAAA;CvBi3DhC;AuBh3DD;EAAqC,iBAAA;CvBm3DpC;AuBl3DD;EAA8B,iBAAA;CvBq3D7B;AuBp3DD;EAAsC,iBAAA;CvBu3DrC;AuBt3DD;EAAuC,iBAAA;CvBy3DtC;AuBx3DD;EAAyC,iBAAA;CvB23DxC;AuB13DD;EAAsC,iBAAA;CvB63DrC;AuB53DD;EAAqC,iBAAA;CvB+3DpC;AuB93DD;EAAsC,iBAAA;CvBi4DrC;AuBh4DD;EAAkC,iBAAA;CvBm4DjC;AuBl4DD;EAAyC,iBAAA;CvBq4DxC;AuBp4DD;EAAsC,iBAAA;CvBu4DrC;AuBt4DD;EAAqC,iBAAA;CvBy4DpC;AuBx4DD;EAAmC,iBAAA;CvB24DlC;AuB14DD;EAA+B,iBAAA;CvB64D9B;AuB54DD;EAAmC,iBAAA;CvB+4DlC;AuB94DD;EAAqC,iBAAA;CvBi5DpC;AuBh5DD;EAA8B,iBAAA;CvBm5D7B;AuBl5DD;;;EAE+B,iBAAA;CvBq5D9B;AuBp5DD;EAAoC,iBAAA;CvBu5DnC;AuBt5DD;EAAsC,iBAAA;CvBy5DrC;AuBx5DD;EAA0C,iBAAA;CvB25DzC;AuB15DD;EAAoC,iBAAA;CvB65DnC;AuB55DD;EAAoC,iBAAA;CvB+5DnC;AuB95DD;EAAmC,iBAAA;CvBi6DlC;AuBh6DD;EAAkC,iBAAA;CvBm6DjC;AuBl6DD;EAAwC,iBAAA;CvBq6DvC;AuBp6DD;EAAuC,iBAAA;CvBu6DtC;AuBt6DD;EAAoC,iBAAA;CvBy6DnC;AuBx6DD;EAAqC,iBAAA;CvB26DpC;AuB16DD;EAA2C,iBAAA;CvB66D1C;AuB56DD;EAAmC,iBAAA;CvB+6DlC;AuB96DD;EAAgC,iBAAA;CvBi7D/B;AuBh7DD;EAAuC,iBAAA;CvBm7DtC;AuBl7DD;EAAsC,iBAAA;CvBq7DrC;AuBp7DD;EAAuC,iBAAA;CvBu7DtC;AuBt7DD;EAAqC,iBAAA;CvBy7DpC;AuBx7DD;EAAiC,iBAAA;CvB27DhC;AuB17DD;EAAgC,iBAAA;CvB67D/B;AuB57DD;EAAmC,iBAAA;CvB+7DlC;AuB97DD;EAAuC,iBAAA;CvBi8DtC;AuBh8DD;EAA2C,iBAAA;CvBm8D1C;AuBl8DD;EAAwC,iBAAA;CvBq8DvC;AuBp8DD;EAAuC,iBAAA;CvBu8DtC;AuBt8DD;EAAsC,iBAAA;CvBy8DrC;AuBx8DD;EAAuC,iBAAA;CvB28DtC;AuB18DD;EAAyC,iBAAA;CvB68DxC;AuB58DD;EAAyC,iBAAA;CvB+8DxC;AuB98DD;EAAkC,iBAAA;CvBi9DjC;AuBh9DD;EAA6C,iBAAA;CvBm9D5C;AuBl9DD;EAAuC,iBAAA;CvBq9DtC;AuBp9DD;EAAoC,iBAAA;CvBu9DnC;AuBt9DD;EAAkC,iBAAA;CvBy9DjC;AuBx9DD;EAAqC,iBAAA;CvB29DpC;AuB19DD;EAAsC,iBAAA;CvB69DrC;AuB59DD;;EAC+B,iBAAA;CvB+9D9B;AuB99DD;EAAmC,iBAAA;CvBi+DlC;AuBh+DD;EAAiC,iBAAA;CvBm+DhC;AuBl+DD;EAAkC,iBAAA;CvBq+DjC;AuBp+DD;EAAkC,iBAAA;CvBu+DjC","file":"Lib.css","sourcesContent":[".layout-editor * {\n  -webkit-box-sizing: border-box;\n  -moz-box-sizing: border-box;\n  box-sizing: border-box;\n}\n.layout-editor *:before,\n.layout-editor *:after {\n  -webkit-box-sizing: border-box;\n  -moz-box-sizing: border-box;\n  box-sizing: border-box;\n}\n.layout-editor html {\n  font-size: 10px;\n  -webkit-tap-highlight-color: rgba(0, 0, 0, 0);\n}\n.layout-editor body {\n  font-family: \"Helvetica Neue\", Helvetica, Arial, sans-serif;\n  font-size: 14px;\n  line-height: 1.42857143;\n  color: #333333;\n  background-color: #fff;\n}\n.layout-editor input,\n.layout-editor button,\n.layout-editor select,\n.layout-editor textarea {\n  font-family: inherit;\n  font-size: inherit;\n  line-height: inherit;\n}\n.layout-editor a {\n  color: #337ab7;\n  text-decoration: none;\n}\n.layout-editor a:hover,\n.layout-editor a:focus {\n  color: #23527c;\n  text-decoration: underline;\n}\n.layout-editor a:focus {\n  outline: thin dotted;\n  outline: 5px auto -webkit-focus-ring-color;\n  outline-offset: -2px;\n}\n.layout-editor figure {\n  margin: 0;\n}\n.layout-editor img {\n  vertical-align: middle;\n}\n.layout-editor .img-responsive {\n  display: block;\n  max-width: 100%;\n  height: auto;\n}\n.layout-editor .img-rounded {\n  border-radius: 6px;\n}\n.layout-editor .img-thumbnail {\n  padding: 4px;\n  line-height: 1.42857143;\n  background-color: #fff;\n  border: 1px solid #ddd;\n  border-radius: 4px;\n  -webkit-transition: all 0.2s ease-in-out;\n  -o-transition: all 0.2s ease-in-out;\n  transition: all 0.2s ease-in-out;\n  display: inline-block;\n  max-width: 100%;\n  height: auto;\n}\n.layout-editor .img-circle {\n  border-radius: 50%;\n}\n.layout-editor hr {\n  margin-top: 20px;\n  margin-bottom: 20px;\n  border: 0;\n  border-top: 1px solid #eeeeee;\n}\n.layout-editor .sr-only {\n  position: absolute;\n  width: 1px;\n  height: 1px;\n  margin: -1px;\n  padding: 0;\n  overflow: hidden;\n  clip: rect(0, 0, 0, 0);\n  border: 0;\n}\n.layout-editor .sr-only-focusable:active,\n.layout-editor .sr-only-focusable:focus {\n  position: static;\n  width: auto;\n  height: auto;\n  margin: 0;\n  overflow: visible;\n  clip: auto;\n}\n.layout-editor .container {\n  margin-right: auto;\n  margin-left: auto;\n  padding-left: 15px;\n  padding-right: 15px;\n}\n@media (min-width: 768px) {\n  .layout-editor .container {\n    width: 750px;\n  }\n}\n@media (min-width: 992px) {\n  .layout-editor .container {\n    width: 970px;\n  }\n}\n@media (min-width: 1200px) {\n  .layout-editor .container {\n    width: 1170px;\n  }\n}\n.layout-editor .container-fluid {\n  margin-right: auto;\n  margin-left: auto;\n  padding-left: 15px;\n  padding-right: 15px;\n}\n.layout-editor .row {\n  margin-left: -15px;\n  margin-right: -15px;\n}\n.layout-editor .col-xs-1, .col-sm-1, .col-md-1, .col-lg-1, .col-xs-2, .col-sm-2, .col-md-2, .col-lg-2, .col-xs-3, .col-sm-3, .col-md-3, .col-lg-3, .col-xs-4, .col-sm-4, .col-md-4, .col-lg-4, .col-xs-5, .col-sm-5, .col-md-5, .col-lg-5, .col-xs-6, .col-sm-6, .col-md-6, .col-lg-6, .col-xs-7, .col-sm-7, .col-md-7, .col-lg-7, .col-xs-8, .col-sm-8, .col-md-8, .col-lg-8, .col-xs-9, .col-sm-9, .col-md-9, .col-lg-9, .col-xs-10, .col-sm-10, .col-md-10, .col-lg-10, .col-xs-11, .col-sm-11, .col-md-11, .col-lg-11, .col-xs-12, .col-sm-12, .col-md-12, .col-lg-12 {\n  position: relative;\n  min-height: 1px;\n  padding-left: 15px;\n  padding-right: 15px;\n}\n.layout-editor .col-xs-1, .col-xs-2, .col-xs-3, .col-xs-4, .col-xs-5, .col-xs-6, .col-xs-7, .col-xs-8, .col-xs-9, .col-xs-10, .col-xs-11, .col-xs-12 {\n  float: left;\n}\n.layout-editor .col-xs-12 {\n  width: 100%;\n}\n.layout-editor .col-xs-11 {\n  width: 91.66666667%;\n}\n.layout-editor .col-xs-10 {\n  width: 83.33333333%;\n}\n.layout-editor .col-xs-9 {\n  width: 75%;\n}\n.layout-editor .col-xs-8 {\n  width: 66.66666667%;\n}\n.layout-editor .col-xs-7 {\n  width: 58.33333333%;\n}\n.layout-editor .col-xs-6 {\n  width: 50%;\n}\n.layout-editor .col-xs-5 {\n  width: 41.66666667%;\n}\n.layout-editor .col-xs-4 {\n  width: 33.33333333%;\n}\n.layout-editor .col-xs-3 {\n  width: 25%;\n}\n.layout-editor .col-xs-2 {\n  width: 16.66666667%;\n}\n.layout-editor .col-xs-1 {\n  width: 8.33333333%;\n}\n.layout-editor .col-xs-pull-12 {\n  right: 100%;\n}\n.layout-editor .col-xs-pull-11 {\n  right: 91.66666667%;\n}\n.layout-editor .col-xs-pull-10 {\n  right: 83.33333333%;\n}\n.layout-editor .col-xs-pull-9 {\n  right: 75%;\n}\n.layout-editor .col-xs-pull-8 {\n  right: 66.66666667%;\n}\n.layout-editor .col-xs-pull-7 {\n  right: 58.33333333%;\n}\n.layout-editor .col-xs-pull-6 {\n  right: 50%;\n}\n.layout-editor .col-xs-pull-5 {\n  right: 41.66666667%;\n}\n.layout-editor .col-xs-pull-4 {\n  right: 33.33333333%;\n}\n.layout-editor .col-xs-pull-3 {\n  right: 25%;\n}\n.layout-editor .col-xs-pull-2 {\n  right: 16.66666667%;\n}\n.layout-editor .col-xs-pull-1 {\n  right: 8.33333333%;\n}\n.layout-editor .col-xs-pull-0 {\n  right: auto;\n}\n.layout-editor .col-xs-push-12 {\n  left: 100%;\n}\n.layout-editor .col-xs-push-11 {\n  left: 91.66666667%;\n}\n.layout-editor .col-xs-push-10 {\n  left: 83.33333333%;\n}\n.layout-editor .col-xs-push-9 {\n  left: 75%;\n}\n.layout-editor .col-xs-push-8 {\n  left: 66.66666667%;\n}\n.layout-editor .col-xs-push-7 {\n  left: 58.33333333%;\n}\n.layout-editor .col-xs-push-6 {\n  left: 50%;\n}\n.layout-editor .col-xs-push-5 {\n  left: 41.66666667%;\n}\n.layout-editor .col-xs-push-4 {\n  left: 33.33333333%;\n}\n.layout-editor .col-xs-push-3 {\n  left: 25%;\n}\n.layout-editor .col-xs-push-2 {\n  left: 16.66666667%;\n}\n.layout-editor .col-xs-push-1 {\n  left: 8.33333333%;\n}\n.layout-editor .col-xs-push-0 {\n  left: auto;\n}\n.layout-editor .col-xs-offset-12 {\n  margin-left: 100%;\n}\n.layout-editor .col-xs-offset-11 {\n  margin-left: 91.66666667%;\n}\n.layout-editor .col-xs-offset-10 {\n  margin-left: 83.33333333%;\n}\n.layout-editor .col-xs-offset-9 {\n  margin-left: 75%;\n}\n.layout-editor .col-xs-offset-8 {\n  margin-left: 66.66666667%;\n}\n.layout-editor .col-xs-offset-7 {\n  margin-left: 58.33333333%;\n}\n.layout-editor .col-xs-offset-6 {\n  margin-left: 50%;\n}\n.layout-editor .col-xs-offset-5 {\n  margin-left: 41.66666667%;\n}\n.layout-editor .col-xs-offset-4 {\n  margin-left: 33.33333333%;\n}\n.layout-editor .col-xs-offset-3 {\n  margin-left: 25%;\n}\n.layout-editor .col-xs-offset-2 {\n  margin-left: 16.66666667%;\n}\n.layout-editor .col-xs-offset-1 {\n  margin-left: 8.33333333%;\n}\n.layout-editor .col-xs-offset-0 {\n  margin-left: 0%;\n}\n@media (min-width: 768px) {\n  .layout-editor .col-sm-1, .col-sm-2, .col-sm-3, .col-sm-4, .col-sm-5, .col-sm-6, .col-sm-7, .col-sm-8, .col-sm-9, .col-sm-10, .col-sm-11, .col-sm-12 {\n    float: left;\n  }\n  .layout-editor .col-sm-12 {\n    width: 100%;\n  }\n  .layout-editor .col-sm-11 {\n    width: 91.66666667%;\n  }\n  .layout-editor .col-sm-10 {\n    width: 83.33333333%;\n  }\n  .layout-editor .col-sm-9 {\n    width: 75%;\n  }\n  .layout-editor .col-sm-8 {\n    width: 66.66666667%;\n  }\n  .layout-editor .col-sm-7 {\n    width: 58.33333333%;\n  }\n  .layout-editor .col-sm-6 {\n    width: 50%;\n  }\n  .layout-editor .col-sm-5 {\n    width: 41.66666667%;\n  }\n  .layout-editor .col-sm-4 {\n    width: 33.33333333%;\n  }\n  .layout-editor .col-sm-3 {\n    width: 25%;\n  }\n  .layout-editor .col-sm-2 {\n    width: 16.66666667%;\n  }\n  .layout-editor .col-sm-1 {\n    width: 8.33333333%;\n  }\n  .layout-editor .col-sm-pull-12 {\n    right: 100%;\n  }\n  .layout-editor .col-sm-pull-11 {\n    right: 91.66666667%;\n  }\n  .layout-editor .col-sm-pull-10 {\n    right: 83.33333333%;\n  }\n  .layout-editor .col-sm-pull-9 {\n    right: 75%;\n  }\n  .layout-editor .col-sm-pull-8 {\n    right: 66.66666667%;\n  }\n  .layout-editor .col-sm-pull-7 {\n    right: 58.33333333%;\n  }\n  .layout-editor .col-sm-pull-6 {\n    right: 50%;\n  }\n  .layout-editor .col-sm-pull-5 {\n    right: 41.66666667%;\n  }\n  .layout-editor .col-sm-pull-4 {\n    right: 33.33333333%;\n  }\n  .layout-editor .col-sm-pull-3 {\n    right: 25%;\n  }\n  .layout-editor .col-sm-pull-2 {\n    right: 16.66666667%;\n  }\n  .layout-editor .col-sm-pull-1 {\n    right: 8.33333333%;\n  }\n  .layout-editor .col-sm-pull-0 {\n    right: auto;\n  }\n  .layout-editor .col-sm-push-12 {\n    left: 100%;\n  }\n  .layout-editor .col-sm-push-11 {\n    left: 91.66666667%;\n  }\n  .layout-editor .col-sm-push-10 {\n    left: 83.33333333%;\n  }\n  .layout-editor .col-sm-push-9 {\n    left: 75%;\n  }\n  .layout-editor .col-sm-push-8 {\n    left: 66.66666667%;\n  }\n  .layout-editor .col-sm-push-7 {\n    left: 58.33333333%;\n  }\n  .layout-editor .col-sm-push-6 {\n    left: 50%;\n  }\n  .layout-editor .col-sm-push-5 {\n    left: 41.66666667%;\n  }\n  .layout-editor .col-sm-push-4 {\n    left: 33.33333333%;\n  }\n  .layout-editor .col-sm-push-3 {\n    left: 25%;\n  }\n  .layout-editor .col-sm-push-2 {\n    left: 16.66666667%;\n  }\n  .layout-editor .col-sm-push-1 {\n    left: 8.33333333%;\n  }\n  .layout-editor .col-sm-push-0 {\n    left: auto;\n  }\n  .layout-editor .col-sm-offset-12 {\n    margin-left: 100%;\n  }\n  .layout-editor .col-sm-offset-11 {\n    margin-left: 91.66666667%;\n  }\n  .layout-editor .col-sm-offset-10 {\n    margin-left: 83.33333333%;\n  }\n  .layout-editor .col-sm-offset-9 {\n    margin-left: 75%;\n  }\n  .layout-editor .col-sm-offset-8 {\n    margin-left: 66.66666667%;\n  }\n  .layout-editor .col-sm-offset-7 {\n    margin-left: 58.33333333%;\n  }\n  .layout-editor .col-sm-offset-6 {\n    margin-left: 50%;\n  }\n  .layout-editor .col-sm-offset-5 {\n    margin-left: 41.66666667%;\n  }\n  .layout-editor .col-sm-offset-4 {\n    margin-left: 33.33333333%;\n  }\n  .layout-editor .col-sm-offset-3 {\n    margin-left: 25%;\n  }\n  .layout-editor .col-sm-offset-2 {\n    margin-left: 16.66666667%;\n  }\n  .layout-editor .col-sm-offset-1 {\n    margin-left: 8.33333333%;\n  }\n  .layout-editor .col-sm-offset-0 {\n    margin-left: 0%;\n  }\n}\n@media (min-width: 992px) {\n  .layout-editor .col-md-1, .col-md-2, .col-md-3, .col-md-4, .col-md-5, .col-md-6, .col-md-7, .col-md-8, .col-md-9, .col-md-10, .col-md-11, .col-md-12 {\n    float: left;\n  }\n  .layout-editor .col-md-12 {\n    width: 100%;\n  }\n  .layout-editor .col-md-11 {\n    width: 91.66666667%;\n  }\n  .layout-editor .col-md-10 {\n    width: 83.33333333%;\n  }\n  .layout-editor .col-md-9 {\n    width: 75%;\n  }\n  .layout-editor .col-md-8 {\n    width: 66.66666667%;\n  }\n  .layout-editor .col-md-7 {\n    width: 58.33333333%;\n  }\n  .layout-editor .col-md-6 {\n    width: 50%;\n  }\n  .layout-editor .col-md-5 {\n    width: 41.66666667%;\n  }\n  .layout-editor .col-md-4 {\n    width: 33.33333333%;\n  }\n  .layout-editor .col-md-3 {\n    width: 25%;\n  }\n  .layout-editor .col-md-2 {\n    width: 16.66666667%;\n  }\n  .layout-editor .col-md-1 {\n    width: 8.33333333%;\n  }\n  .layout-editor .col-md-pull-12 {\n    right: 100%;\n  }\n  .layout-editor .col-md-pull-11 {\n    right: 91.66666667%;\n  }\n  .layout-editor .col-md-pull-10 {\n    right: 83.33333333%;\n  }\n  .layout-editor .col-md-pull-9 {\n    right: 75%;\n  }\n  .layout-editor .col-md-pull-8 {\n    right: 66.66666667%;\n  }\n  .layout-editor .col-md-pull-7 {\n    right: 58.33333333%;\n  }\n  .layout-editor .col-md-pull-6 {\n    right: 50%;\n  }\n  .layout-editor .col-md-pull-5 {\n    right: 41.66666667%;\n  }\n  .layout-editor .col-md-pull-4 {\n    right: 33.33333333%;\n  }\n  .layout-editor .col-md-pull-3 {\n    right: 25%;\n  }\n  .layout-editor .col-md-pull-2 {\n    right: 16.66666667%;\n  }\n  .layout-editor .col-md-pull-1 {\n    right: 8.33333333%;\n  }\n  .layout-editor .col-md-pull-0 {\n    right: auto;\n  }\n  .layout-editor .col-md-push-12 {\n    left: 100%;\n  }\n  .layout-editor .col-md-push-11 {\n    left: 91.66666667%;\n  }\n  .layout-editor .col-md-push-10 {\n    left: 83.33333333%;\n  }\n  .layout-editor .col-md-push-9 {\n    left: 75%;\n  }\n  .layout-editor .col-md-push-8 {\n    left: 66.66666667%;\n  }\n  .layout-editor .col-md-push-7 {\n    left: 58.33333333%;\n  }\n  .layout-editor .col-md-push-6 {\n    left: 50%;\n  }\n  .layout-editor .col-md-push-5 {\n    left: 41.66666667%;\n  }\n  .layout-editor .col-md-push-4 {\n    left: 33.33333333%;\n  }\n  .layout-editor .col-md-push-3 {\n    left: 25%;\n  }\n  .layout-editor .col-md-push-2 {\n    left: 16.66666667%;\n  }\n  .layout-editor .col-md-push-1 {\n    left: 8.33333333%;\n  }\n  .layout-editor .col-md-push-0 {\n    left: auto;\n  }\n  .layout-editor .col-md-offset-12 {\n    margin-left: 100%;\n  }\n  .layout-editor .col-md-offset-11 {\n    margin-left: 91.66666667%;\n  }\n  .layout-editor .col-md-offset-10 {\n    margin-left: 83.33333333%;\n  }\n  .layout-editor .col-md-offset-9 {\n    margin-left: 75%;\n  }\n  .layout-editor .col-md-offset-8 {\n    margin-left: 66.66666667%;\n  }\n  .layout-editor .col-md-offset-7 {\n    margin-left: 58.33333333%;\n  }\n  .layout-editor .col-md-offset-6 {\n    margin-left: 50%;\n  }\n  .layout-editor .col-md-offset-5 {\n    margin-left: 41.66666667%;\n  }\n  .layout-editor .col-md-offset-4 {\n    margin-left: 33.33333333%;\n  }\n  .layout-editor .col-md-offset-3 {\n    margin-left: 25%;\n  }\n  .layout-editor .col-md-offset-2 {\n    margin-left: 16.66666667%;\n  }\n  .layout-editor .col-md-offset-1 {\n    margin-left: 8.33333333%;\n  }\n  .layout-editor .col-md-offset-0 {\n    margin-left: 0%;\n  }\n}\n@media (min-width: 1200px) {\n  .layout-editor .col-lg-1, .col-lg-2, .col-lg-3, .col-lg-4, .col-lg-5, .col-lg-6, .col-lg-7, .col-lg-8, .col-lg-9, .col-lg-10, .col-lg-11, .col-lg-12 {\n    float: left;\n  }\n  .layout-editor .col-lg-12 {\n    width: 100%;\n  }\n  .layout-editor .col-lg-11 {\n    width: 91.66666667%;\n  }\n  .layout-editor .col-lg-10 {\n    width: 83.33333333%;\n  }\n  .layout-editor .col-lg-9 {\n    width: 75%;\n  }\n  .layout-editor .col-lg-8 {\n    width: 66.66666667%;\n  }\n  .layout-editor .col-lg-7 {\n    width: 58.33333333%;\n  }\n  .layout-editor .col-lg-6 {\n    width: 50%;\n  }\n  .layout-editor .col-lg-5 {\n    width: 41.66666667%;\n  }\n  .layout-editor .col-lg-4 {\n    width: 33.33333333%;\n  }\n  .layout-editor .col-lg-3 {\n    width: 25%;\n  }\n  .layout-editor .col-lg-2 {\n    width: 16.66666667%;\n  }\n  .layout-editor .col-lg-1 {\n    width: 8.33333333%;\n  }\n  .layout-editor .col-lg-pull-12 {\n    right: 100%;\n  }\n  .layout-editor .col-lg-pull-11 {\n    right: 91.66666667%;\n  }\n  .layout-editor .col-lg-pull-10 {\n    right: 83.33333333%;\n  }\n  .layout-editor .col-lg-pull-9 {\n    right: 75%;\n  }\n  .layout-editor .col-lg-pull-8 {\n    right: 66.66666667%;\n  }\n  .layout-editor .col-lg-pull-7 {\n    right: 58.33333333%;\n  }\n  .layout-editor .col-lg-pull-6 {\n    right: 50%;\n  }\n  .layout-editor .col-lg-pull-5 {\n    right: 41.66666667%;\n  }\n  .layout-editor .col-lg-pull-4 {\n    right: 33.33333333%;\n  }\n  .layout-editor .col-lg-pull-3 {\n    right: 25%;\n  }\n  .layout-editor .col-lg-pull-2 {\n    right: 16.66666667%;\n  }\n  .layout-editor .col-lg-pull-1 {\n    right: 8.33333333%;\n  }\n  .layout-editor .col-lg-pull-0 {\n    right: auto;\n  }\n  .layout-editor .col-lg-push-12 {\n    left: 100%;\n  }\n  .layout-editor .col-lg-push-11 {\n    left: 91.66666667%;\n  }\n  .layout-editor .col-lg-push-10 {\n    left: 83.33333333%;\n  }\n  .layout-editor .col-lg-push-9 {\n    left: 75%;\n  }\n  .layout-editor .col-lg-push-8 {\n    left: 66.66666667%;\n  }\n  .layout-editor .col-lg-push-7 {\n    left: 58.33333333%;\n  }\n  .layout-editor .col-lg-push-6 {\n    left: 50%;\n  }\n  .layout-editor .col-lg-push-5 {\n    left: 41.66666667%;\n  }\n  .layout-editor .col-lg-push-4 {\n    left: 33.33333333%;\n  }\n  .layout-editor .col-lg-push-3 {\n    left: 25%;\n  }\n  .layout-editor .col-lg-push-2 {\n    left: 16.66666667%;\n  }\n  .layout-editor .col-lg-push-1 {\n    left: 8.33333333%;\n  }\n  .layout-editor .col-lg-push-0 {\n    left: auto;\n  }\n  .layout-editor .col-lg-offset-12 {\n    margin-left: 100%;\n  }\n  .layout-editor .col-lg-offset-11 {\n    margin-left: 91.66666667%;\n  }\n  .layout-editor .col-lg-offset-10 {\n    margin-left: 83.33333333%;\n  }\n  .layout-editor .col-lg-offset-9 {\n    margin-left: 75%;\n  }\n  .layout-editor .col-lg-offset-8 {\n    margin-left: 66.66666667%;\n  }\n  .layout-editor .col-lg-offset-7 {\n    margin-left: 58.33333333%;\n  }\n  .layout-editor .col-lg-offset-6 {\n    margin-left: 50%;\n  }\n  .layout-editor .col-lg-offset-5 {\n    margin-left: 41.66666667%;\n  }\n  .layout-editor .col-lg-offset-4 {\n    margin-left: 33.33333333%;\n  }\n  .layout-editor .col-lg-offset-3 {\n    margin-left: 25%;\n  }\n  .layout-editor .col-lg-offset-2 {\n    margin-left: 16.66666667%;\n  }\n  .layout-editor .col-lg-offset-1 {\n    margin-left: 8.33333333%;\n  }\n  .layout-editor .col-lg-offset-0 {\n    margin-left: 0%;\n  }\n}\n.clearfix:before,\n.clearfix:after,\n.layout-editor .container:before,\n.layout-editor .container:after,\n.layout-editor .container-fluid:before,\n.layout-editor .container-fluid:after,\n.layout-editor .row:before,\n.layout-editor .row:after {\n  content: \" \";\n  display: table;\n}\n.clearfix:after,\n.layout-editor .container:after,\n.layout-editor .container-fluid:after,\n.layout-editor .row:after {\n  clear: both;\n}\n.center-block {\n  display: block;\n  margin-left: auto;\n  margin-right: auto;\n}\n.pull-right {\n  float: right !important;\n}\n.pull-left {\n  float: left !important;\n}\n.hide {\n  display: none !important;\n}\n.show {\n  display: block !important;\n}\n.invisible {\n  visibility: hidden;\n}\n.text-hide {\n  font: 0/0 a;\n  color: transparent;\n  text-shadow: none;\n  background-color: transparent;\n  border: 0;\n}\n.hidden {\n  display: none !important;\n  visibility: hidden !important;\n}\n.affix {\n  position: fixed;\n}\n\n/*!\n *  Font Awesome 4.3.0 by @davegandy - http://fontawesome.io - @fontawesome\n *  License - http://fontawesome.io/license (Font: SIL OFL 1.1, CSS: MIT License)\n */\n/* FONT PATH\n * -------------------------- */\n@font-face {\n  font-family: 'FontAwesome';\n  src: url('Fonts/fontawesome-webfont.eot?v=4.3.0');\n  src: url('Fonts/fontawesome-webfont.eot?#iefix&v=4.3.0') format('embedded-opentype'), url('Fonts/fontawesome-webfont.woff2?v=4.3.0') format('woff2'), url('Fonts/fontawesome-webfont.woff?v=4.3.0') format('woff'), url('Fonts/fontawesome-webfont.ttf?v=4.3.0') format('truetype'), url('Fonts/fontawesome-webfont.svg?v=4.3.0#fontawesomeregular') format('svg');\n  font-weight: normal;\n  font-style: normal;\n}\n.fa {\n  display: inline-block;\n  font: normal normal normal 14px/1 FontAwesome;\n  font-size: inherit;\n  text-rendering: auto;\n  -webkit-font-smoothing: antialiased;\n  -moz-osx-font-smoothing: grayscale;\n  transform: translate(0, 0);\n}\n/* makes the font 33% larger relative to the icon container */\n.fa-lg {\n  font-size: 1.33333333em;\n  line-height: 0.75em;\n  vertical-align: -15%;\n}\n.fa-2x {\n  font-size: 2em;\n}\n.fa-3x {\n  font-size: 3em;\n}\n.fa-4x {\n  font-size: 4em;\n}\n.fa-5x {\n  font-size: 5em;\n}\n.fa-fw {\n  width: 1.28571429em;\n  text-align: center;\n}\n.fa-ul {\n  padding-left: 0;\n  margin-left: 2.14285714em;\n  list-style-type: none;\n}\n.fa-ul > li {\n  position: relative;\n}\n.fa-li {\n  position: absolute;\n  left: -2.14285714em;\n  width: 2.14285714em;\n  top: 0.14285714em;\n  text-align: center;\n}\n.fa-li.fa-lg {\n  left: -1.85714286em;\n}\n.fa-border {\n  padding: .2em .25em .15em;\n  border: solid 0.08em #eee;\n  border-radius: .1em;\n}\n.pull-right {\n  float: right;\n}\n.pull-left {\n  float: left;\n}\n.fa.pull-left {\n  margin-right: .3em;\n}\n.fa.pull-right {\n  margin-left: .3em;\n}\n.fa-spin {\n  -webkit-animation: fa-spin 2s infinite linear;\n  animation: fa-spin 2s infinite linear;\n}\n.fa-pulse {\n  -webkit-animation: fa-spin 1s infinite steps(8);\n  animation: fa-spin 1s infinite steps(8);\n}\n@-webkit-keyframes fa-spin {\n  0% {\n    -webkit-transform: rotate(0deg);\n    transform: rotate(0deg);\n  }\n  100% {\n    -webkit-transform: rotate(359deg);\n    transform: rotate(359deg);\n  }\n}\n@keyframes fa-spin {\n  0% {\n    -webkit-transform: rotate(0deg);\n    transform: rotate(0deg);\n  }\n  100% {\n    -webkit-transform: rotate(359deg);\n    transform: rotate(359deg);\n  }\n}\n.fa-rotate-90 {\n  filter: progid:DXImageTransform.Microsoft.BasicImage(rotation=1);\n  -webkit-transform: rotate(90deg);\n  -ms-transform: rotate(90deg);\n  transform: rotate(90deg);\n}\n.fa-rotate-180 {\n  filter: progid:DXImageTransform.Microsoft.BasicImage(rotation=2);\n  -webkit-transform: rotate(180deg);\n  -ms-transform: rotate(180deg);\n  transform: rotate(180deg);\n}\n.fa-rotate-270 {\n  filter: progid:DXImageTransform.Microsoft.BasicImage(rotation=3);\n  -webkit-transform: rotate(270deg);\n  -ms-transform: rotate(270deg);\n  transform: rotate(270deg);\n}\n.fa-flip-horizontal {\n  filter: progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1);\n  -webkit-transform: scale(-1, 1);\n  -ms-transform: scale(-1, 1);\n  transform: scale(-1, 1);\n}\n.fa-flip-vertical {\n  filter: progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1);\n  -webkit-transform: scale(1, -1);\n  -ms-transform: scale(1, -1);\n  transform: scale(1, -1);\n}\n:root .fa-rotate-90,\n:root .fa-rotate-180,\n:root .fa-rotate-270,\n:root .fa-flip-horizontal,\n:root .fa-flip-vertical {\n  filter: none;\n}\n.fa-stack {\n  position: relative;\n  display: inline-block;\n  width: 2em;\n  height: 2em;\n  line-height: 2em;\n  vertical-align: middle;\n}\n.fa-stack-1x,\n.fa-stack-2x {\n  position: absolute;\n  left: 0;\n  width: 100%;\n  text-align: center;\n}\n.fa-stack-1x {\n  line-height: inherit;\n}\n.fa-stack-2x {\n  font-size: 2em;\n}\n.fa-inverse {\n  color: #fff;\n}\n/* Font Awesome uses the Unicode Private Use Area (PUA) to ensure screen\n   readers do not read off random characters that represent icons */\n.fa-glass:before {\n  content: \"\\f000\";\n}\n.fa-music:before {\n  content: \"\\f001\";\n}\n.fa-search:before {\n  content: \"\\f002\";\n}\n.fa-envelope-o:before {\n  content: \"\\f003\";\n}\n.fa-heart:before {\n  content: \"\\f004\";\n}\n.fa-star:before {\n  content: \"\\f005\";\n}\n.fa-star-o:before {\n  content: \"\\f006\";\n}\n.fa-user:before {\n  content: \"\\f007\";\n}\n.fa-film:before {\n  content: \"\\f008\";\n}\n.fa-th-large:before {\n  content: \"\\f009\";\n}\n.fa-th:before {\n  content: \"\\f00a\";\n}\n.fa-th-list:before {\n  content: \"\\f00b\";\n}\n.fa-check:before {\n  content: \"\\f00c\";\n}\n.fa-remove:before,\n.fa-close:before,\n.fa-times:before {\n  content: \"\\f00d\";\n}\n.fa-search-plus:before {\n  content: \"\\f00e\";\n}\n.fa-search-minus:before {\n  content: \"\\f010\";\n}\n.fa-power-off:before {\n  content: \"\\f011\";\n}\n.fa-signal:before {\n  content: \"\\f012\";\n}\n.fa-gear:before,\n.fa-cog:before {\n  content: \"\\f013\";\n}\n.fa-trash-o:before {\n  content: \"\\f014\";\n}\n.fa-home:before {\n  content: \"\\f015\";\n}\n.fa-file-o:before {\n  content: \"\\f016\";\n}\n.fa-clock-o:before {\n  content: \"\\f017\";\n}\n.fa-road:before {\n  content: \"\\f018\";\n}\n.fa-download:before {\n  content: \"\\f019\";\n}\n.fa-arrow-circle-o-down:before {\n  content: \"\\f01a\";\n}\n.fa-arrow-circle-o-up:before {\n  content: \"\\f01b\";\n}\n.fa-inbox:before {\n  content: \"\\f01c\";\n}\n.fa-play-circle-o:before {\n  content: \"\\f01d\";\n}\n.fa-rotate-right:before,\n.fa-repeat:before {\n  content: \"\\f01e\";\n}\n.fa-refresh:before {\n  content: \"\\f021\";\n}\n.fa-list-alt:before {\n  content: \"\\f022\";\n}\n.fa-lock:before {\n  content: \"\\f023\";\n}\n.fa-flag:before {\n  content: \"\\f024\";\n}\n.fa-headphones:before {\n  content: \"\\f025\";\n}\n.fa-volume-off:before {\n  content: \"\\f026\";\n}\n.fa-volume-down:before {\n  content: \"\\f027\";\n}\n.fa-volume-up:before {\n  content: \"\\f028\";\n}\n.fa-qrcode:before {\n  content: \"\\f029\";\n}\n.fa-barcode:before {\n  content: \"\\f02a\";\n}\n.fa-tag:before {\n  content: \"\\f02b\";\n}\n.fa-tags:before {\n  content: \"\\f02c\";\n}\n.fa-book:before {\n  content: \"\\f02d\";\n}\n.fa-bookmark:before {\n  content: \"\\f02e\";\n}\n.fa-print:before {\n  content: \"\\f02f\";\n}\n.fa-camera:before {\n  content: \"\\f030\";\n}\n.fa-font:before {\n  content: \"\\f031\";\n}\n.fa-bold:before {\n  content: \"\\f032\";\n}\n.fa-italic:before {\n  content: \"\\f033\";\n}\n.fa-text-height:before {\n  content: \"\\f034\";\n}\n.fa-text-width:before {\n  content: \"\\f035\";\n}\n.fa-align-left:before {\n  content: \"\\f036\";\n}\n.fa-align-center:before {\n  content: \"\\f037\";\n}\n.fa-align-right:before {\n  content: \"\\f038\";\n}\n.fa-align-justify:before {\n  content: \"\\f039\";\n}\n.fa-list:before {\n  content: \"\\f03a\";\n}\n.fa-dedent:before,\n.fa-outdent:before {\n  content: \"\\f03b\";\n}\n.fa-indent:before {\n  content: \"\\f03c\";\n}\n.fa-video-camera:before {\n  content: \"\\f03d\";\n}\n.fa-photo:before,\n.fa-image:before,\n.fa-picture-o:before {\n  content: \"\\f03e\";\n}\n.fa-pencil:before {\n  content: \"\\f040\";\n}\n.fa-map-marker:before {\n  content: \"\\f041\";\n}\n.fa-adjust:before {\n  content: \"\\f042\";\n}\n.fa-tint:before {\n  content: \"\\f043\";\n}\n.fa-edit:before,\n.fa-pencil-square-o:before {\n  content: \"\\f044\";\n}\n.fa-share-square-o:before {\n  content: \"\\f045\";\n}\n.fa-check-square-o:before {\n  content: \"\\f046\";\n}\n.fa-arrows:before {\n  content: \"\\f047\";\n}\n.fa-step-backward:before {\n  content: \"\\f048\";\n}\n.fa-fast-backward:before {\n  content: \"\\f049\";\n}\n.fa-backward:before {\n  content: \"\\f04a\";\n}\n.fa-play:before {\n  content: \"\\f04b\";\n}\n.fa-pause:before {\n  content: \"\\f04c\";\n}\n.fa-stop:before {\n  content: \"\\f04d\";\n}\n.fa-forward:before {\n  content: \"\\f04e\";\n}\n.fa-fast-forward:before {\n  content: \"\\f050\";\n}\n.fa-step-forward:before {\n  content: \"\\f051\";\n}\n.fa-eject:before {\n  content: \"\\f052\";\n}\n.fa-chevron-left:before {\n  content: \"\\f053\";\n}\n.fa-chevron-right:before {\n  content: \"\\f054\";\n}\n.fa-plus-circle:before {\n  content: \"\\f055\";\n}\n.fa-minus-circle:before {\n  content: \"\\f056\";\n}\n.fa-times-circle:before {\n  content: \"\\f057\";\n}\n.fa-check-circle:before {\n  content: \"\\f058\";\n}\n.fa-question-circle:before {\n  content: \"\\f059\";\n}\n.fa-info-circle:before {\n  content: \"\\f05a\";\n}\n.fa-crosshairs:before {\n  content: \"\\f05b\";\n}\n.fa-times-circle-o:before {\n  content: \"\\f05c\";\n}\n.fa-check-circle-o:before {\n  content: \"\\f05d\";\n}\n.fa-ban:before {\n  content: \"\\f05e\";\n}\n.fa-arrow-left:before {\n  content: \"\\f060\";\n}\n.fa-arrow-right:before {\n  content: \"\\f061\";\n}\n.fa-arrow-up:before {\n  content: \"\\f062\";\n}\n.fa-arrow-down:before {\n  content: \"\\f063\";\n}\n.fa-mail-forward:before,\n.fa-share:before {\n  content: \"\\f064\";\n}\n.fa-expand:before {\n  content: \"\\f065\";\n}\n.fa-compress:before {\n  content: \"\\f066\";\n}\n.fa-plus:before {\n  content: \"\\f067\";\n}\n.fa-minus:before {\n  content: \"\\f068\";\n}\n.fa-asterisk:before {\n  content: \"\\f069\";\n}\n.fa-exclamation-circle:before {\n  content: \"\\f06a\";\n}\n.fa-gift:before {\n  content: \"\\f06b\";\n}\n.fa-leaf:before {\n  content: \"\\f06c\";\n}\n.fa-fire:before {\n  content: \"\\f06d\";\n}\n.fa-eye:before {\n  content: \"\\f06e\";\n}\n.fa-eye-slash:before {\n  content: \"\\f070\";\n}\n.fa-warning:before,\n.fa-exclamation-triangle:before {\n  content: \"\\f071\";\n}\n.fa-plane:before {\n  content: \"\\f072\";\n}\n.fa-calendar:before {\n  content: \"\\f073\";\n}\n.fa-random:before {\n  content: \"\\f074\";\n}\n.fa-comment:before {\n  content: \"\\f075\";\n}\n.fa-magnet:before {\n  content: \"\\f076\";\n}\n.fa-chevron-up:before {\n  content: \"\\f077\";\n}\n.fa-chevron-down:before {\n  content: \"\\f078\";\n}\n.fa-retweet:before {\n  content: \"\\f079\";\n}\n.fa-shopping-cart:before {\n  content: \"\\f07a\";\n}\n.fa-folder:before {\n  content: \"\\f07b\";\n}\n.fa-folder-open:before {\n  content: \"\\f07c\";\n}\n.fa-arrows-v:before {\n  content: \"\\f07d\";\n}\n.fa-arrows-h:before {\n  content: \"\\f07e\";\n}\n.fa-bar-chart-o:before,\n.fa-bar-chart:before {\n  content: \"\\f080\";\n}\n.fa-twitter-square:before {\n  content: \"\\f081\";\n}\n.fa-facebook-square:before {\n  content: \"\\f082\";\n}\n.fa-camera-retro:before {\n  content: \"\\f083\";\n}\n.fa-key:before {\n  content: \"\\f084\";\n}\n.fa-gears:before,\n.fa-cogs:before {\n  content: \"\\f085\";\n}\n.fa-comments:before {\n  content: \"\\f086\";\n}\n.fa-thumbs-o-up:before {\n  content: \"\\f087\";\n}\n.fa-thumbs-o-down:before {\n  content: \"\\f088\";\n}\n.fa-star-half:before {\n  content: \"\\f089\";\n}\n.fa-heart-o:before {\n  content: \"\\f08a\";\n}\n.fa-sign-out:before {\n  content: \"\\f08b\";\n}\n.fa-linkedin-square:before {\n  content: \"\\f08c\";\n}\n.fa-thumb-tack:before {\n  content: \"\\f08d\";\n}\n.fa-external-link:before {\n  content: \"\\f08e\";\n}\n.fa-sign-in:before {\n  content: \"\\f090\";\n}\n.fa-trophy:before {\n  content: \"\\f091\";\n}\n.fa-github-square:before {\n  content: \"\\f092\";\n}\n.fa-upload:before {\n  content: \"\\f093\";\n}\n.fa-lemon-o:before {\n  content: \"\\f094\";\n}\n.fa-phone:before {\n  content: \"\\f095\";\n}\n.fa-square-o:before {\n  content: \"\\f096\";\n}\n.fa-bookmark-o:before {\n  content: \"\\f097\";\n}\n.fa-phone-square:before {\n  content: \"\\f098\";\n}\n.fa-twitter:before {\n  content: \"\\f099\";\n}\n.fa-facebook-f:before,\n.fa-facebook:before {\n  content: \"\\f09a\";\n}\n.fa-github:before {\n  content: \"\\f09b\";\n}\n.fa-unlock:before {\n  content: \"\\f09c\";\n}\n.fa-credit-card:before {\n  content: \"\\f09d\";\n}\n.fa-rss:before {\n  content: \"\\f09e\";\n}\n.fa-hdd-o:before {\n  content: \"\\f0a0\";\n}\n.fa-bullhorn:before {\n  content: \"\\f0a1\";\n}\n.fa-bell:before {\n  content: \"\\f0f3\";\n}\n.fa-certificate:before {\n  content: \"\\f0a3\";\n}\n.fa-hand-o-right:before {\n  content: \"\\f0a4\";\n}\n.fa-hand-o-left:before {\n  content: \"\\f0a5\";\n}\n.fa-hand-o-up:before {\n  content: \"\\f0a6\";\n}\n.fa-hand-o-down:before {\n  content: \"\\f0a7\";\n}\n.fa-arrow-circle-left:before {\n  content: \"\\f0a8\";\n}\n.fa-arrow-circle-right:before {\n  content: \"\\f0a9\";\n}\n.fa-arrow-circle-up:before {\n  content: \"\\f0aa\";\n}\n.fa-arrow-circle-down:before {\n  content: \"\\f0ab\";\n}\n.fa-globe:before {\n  content: \"\\f0ac\";\n}\n.fa-wrench:before {\n  content: \"\\f0ad\";\n}\n.fa-tasks:before {\n  content: \"\\f0ae\";\n}\n.fa-filter:before {\n  content: \"\\f0b0\";\n}\n.fa-briefcase:before {\n  content: \"\\f0b1\";\n}\n.fa-arrows-alt:before {\n  content: \"\\f0b2\";\n}\n.fa-group:before,\n.fa-users:before {\n  content: \"\\f0c0\";\n}\n.fa-chain:before,\n.fa-link:before {\n  content: \"\\f0c1\";\n}\n.fa-cloud:before {\n  content: \"\\f0c2\";\n}\n.fa-flask:before {\n  content: \"\\f0c3\";\n}\n.fa-cut:before,\n.fa-scissors:before {\n  content: \"\\f0c4\";\n}\n.fa-copy:before,\n.fa-files-o:before {\n  content: \"\\f0c5\";\n}\n.fa-paperclip:before {\n  content: \"\\f0c6\";\n}\n.fa-save:before,\n.fa-floppy-o:before {\n  content: \"\\f0c7\";\n}\n.fa-square:before {\n  content: \"\\f0c8\";\n}\n.fa-navicon:before,\n.fa-reorder:before,\n.fa-bars:before {\n  content: \"\\f0c9\";\n}\n.fa-list-ul:before {\n  content: \"\\f0ca\";\n}\n.fa-list-ol:before {\n  content: \"\\f0cb\";\n}\n.fa-strikethrough:before {\n  content: \"\\f0cc\";\n}\n.fa-underline:before {\n  content: \"\\f0cd\";\n}\n.fa-table:before {\n  content: \"\\f0ce\";\n}\n.fa-magic:before {\n  content: \"\\f0d0\";\n}\n.fa-truck:before {\n  content: \"\\f0d1\";\n}\n.fa-pinterest:before {\n  content: \"\\f0d2\";\n}\n.fa-pinterest-square:before {\n  content: \"\\f0d3\";\n}\n.fa-google-plus-square:before {\n  content: \"\\f0d4\";\n}\n.fa-google-plus:before {\n  content: \"\\f0d5\";\n}\n.fa-money:before {\n  content: \"\\f0d6\";\n}\n.fa-caret-down:before {\n  content: \"\\f0d7\";\n}\n.fa-caret-up:before {\n  content: \"\\f0d8\";\n}\n.fa-caret-left:before {\n  content: \"\\f0d9\";\n}\n.fa-caret-right:before {\n  content: \"\\f0da\";\n}\n.fa-columns:before {\n  content: \"\\f0db\";\n}\n.fa-unsorted:before,\n.fa-sort:before {\n  content: \"\\f0dc\";\n}\n.fa-sort-down:before,\n.fa-sort-desc:before {\n  content: \"\\f0dd\";\n}\n.fa-sort-up:before,\n.fa-sort-asc:before {\n  content: \"\\f0de\";\n}\n.fa-envelope:before {\n  content: \"\\f0e0\";\n}\n.fa-linkedin:before {\n  content: \"\\f0e1\";\n}\n.fa-rotate-left:before,\n.fa-undo:before {\n  content: \"\\f0e2\";\n}\n.fa-legal:before,\n.fa-gavel:before {\n  content: \"\\f0e3\";\n}\n.fa-dashboard:before,\n.fa-tachometer:before {\n  content: \"\\f0e4\";\n}\n.fa-comment-o:before {\n  content: \"\\f0e5\";\n}\n.fa-comments-o:before {\n  content: \"\\f0e6\";\n}\n.fa-flash:before,\n.fa-bolt:before {\n  content: \"\\f0e7\";\n}\n.fa-sitemap:before {\n  content: \"\\f0e8\";\n}\n.fa-umbrella:before {\n  content: \"\\f0e9\";\n}\n.fa-paste:before,\n.fa-clipboard:before {\n  content: \"\\f0ea\";\n}\n.fa-lightbulb-o:before {\n  content: \"\\f0eb\";\n}\n.fa-exchange:before {\n  content: \"\\f0ec\";\n}\n.fa-cloud-download:before {\n  content: \"\\f0ed\";\n}\n.fa-cloud-upload:before {\n  content: \"\\f0ee\";\n}\n.fa-user-md:before {\n  content: \"\\f0f0\";\n}\n.fa-stethoscope:before {\n  content: \"\\f0f1\";\n}\n.fa-suitcase:before {\n  content: \"\\f0f2\";\n}\n.fa-bell-o:before {\n  content: \"\\f0a2\";\n}\n.fa-coffee:before {\n  content: \"\\f0f4\";\n}\n.fa-cutlery:before {\n  content: \"\\f0f5\";\n}\n.fa-file-text-o:before {\n  content: \"\\f0f6\";\n}\n.fa-building-o:before {\n  content: \"\\f0f7\";\n}\n.fa-hospital-o:before {\n  content: \"\\f0f8\";\n}\n.fa-ambulance:before {\n  content: \"\\f0f9\";\n}\n.fa-medkit:before {\n  content: \"\\f0fa\";\n}\n.fa-fighter-jet:before {\n  content: \"\\f0fb\";\n}\n.fa-beer:before {\n  content: \"\\f0fc\";\n}\n.fa-h-square:before {\n  content: \"\\f0fd\";\n}\n.fa-plus-square:before {\n  content: \"\\f0fe\";\n}\n.fa-angle-double-left:before {\n  content: \"\\f100\";\n}\n.fa-angle-double-right:before {\n  content: \"\\f101\";\n}\n.fa-angle-double-up:before {\n  content: \"\\f102\";\n}\n.fa-angle-double-down:before {\n  content: \"\\f103\";\n}\n.fa-angle-left:before {\n  content: \"\\f104\";\n}\n.fa-angle-right:before {\n  content: \"\\f105\";\n}\n.fa-angle-up:before {\n  content: \"\\f106\";\n}\n.fa-angle-down:before {\n  content: \"\\f107\";\n}\n.fa-desktop:before {\n  content: \"\\f108\";\n}\n.fa-laptop:before {\n  content: \"\\f109\";\n}\n.fa-tablet:before {\n  content: \"\\f10a\";\n}\n.fa-mobile-phone:before,\n.fa-mobile:before {\n  content: \"\\f10b\";\n}\n.fa-circle-o:before {\n  content: \"\\f10c\";\n}\n.fa-quote-left:before {\n  content: \"\\f10d\";\n}\n.fa-quote-right:before {\n  content: \"\\f10e\";\n}\n.fa-spinner:before {\n  content: \"\\f110\";\n}\n.fa-circle:before {\n  content: \"\\f111\";\n}\n.fa-mail-reply:before,\n.fa-reply:before {\n  content: \"\\f112\";\n}\n.fa-github-alt:before {\n  content: \"\\f113\";\n}\n.fa-folder-o:before {\n  content: \"\\f114\";\n}\n.fa-folder-open-o:before {\n  content: \"\\f115\";\n}\n.fa-smile-o:before {\n  content: \"\\f118\";\n}\n.fa-frown-o:before {\n  content: \"\\f119\";\n}\n.fa-meh-o:before {\n  content: \"\\f11a\";\n}\n.fa-gamepad:before {\n  content: \"\\f11b\";\n}\n.fa-keyboard-o:before {\n  content: \"\\f11c\";\n}\n.fa-flag-o:before {\n  content: \"\\f11d\";\n}\n.fa-flag-checkered:before {\n  content: \"\\f11e\";\n}\n.fa-terminal:before {\n  content: \"\\f120\";\n}\n.fa-code:before {\n  content: \"\\f121\";\n}\n.fa-mail-reply-all:before,\n.fa-reply-all:before {\n  content: \"\\f122\";\n}\n.fa-star-half-empty:before,\n.fa-star-half-full:before,\n.fa-star-half-o:before {\n  content: \"\\f123\";\n}\n.fa-location-arrow:before {\n  content: \"\\f124\";\n}\n.fa-crop:before {\n  content: \"\\f125\";\n}\n.fa-code-fork:before {\n  content: \"\\f126\";\n}\n.fa-unlink:before,\n.fa-chain-broken:before {\n  content: \"\\f127\";\n}\n.fa-question:before {\n  content: \"\\f128\";\n}\n.fa-info:before {\n  content: \"\\f129\";\n}\n.fa-exclamation:before {\n  content: \"\\f12a\";\n}\n.fa-superscript:before {\n  content: \"\\f12b\";\n}\n.fa-subscript:before {\n  content: \"\\f12c\";\n}\n.fa-eraser:before {\n  content: \"\\f12d\";\n}\n.fa-puzzle-piece:before {\n  content: \"\\f12e\";\n}\n.fa-microphone:before {\n  content: \"\\f130\";\n}\n.fa-microphone-slash:before {\n  content: \"\\f131\";\n}\n.fa-shield:before {\n  content: \"\\f132\";\n}\n.fa-calendar-o:before {\n  content: \"\\f133\";\n}\n.fa-fire-extinguisher:before {\n  content: \"\\f134\";\n}\n.fa-rocket:before {\n  content: \"\\f135\";\n}\n.fa-maxcdn:before {\n  content: \"\\f136\";\n}\n.fa-chevron-circle-left:before {\n  content: \"\\f137\";\n}\n.fa-chevron-circle-right:before {\n  content: \"\\f138\";\n}\n.fa-chevron-circle-up:before {\n  content: \"\\f139\";\n}\n.fa-chevron-circle-down:before {\n  content: \"\\f13a\";\n}\n.fa-html5:before {\n  content: \"\\f13b\";\n}\n.fa-css3:before {\n  content: \"\\f13c\";\n}\n.fa-anchor:before {\n  content: \"\\f13d\";\n}\n.fa-unlock-alt:before {\n  content: \"\\f13e\";\n}\n.fa-bullseye:before {\n  content: \"\\f140\";\n}\n.fa-ellipsis-h:before {\n  content: \"\\f141\";\n}\n.fa-ellipsis-v:before {\n  content: \"\\f142\";\n}\n.fa-rss-square:before {\n  content: \"\\f143\";\n}\n.fa-play-circle:before {\n  content: \"\\f144\";\n}\n.fa-ticket:before {\n  content: \"\\f145\";\n}\n.fa-minus-square:before {\n  content: \"\\f146\";\n}\n.fa-minus-square-o:before {\n  content: \"\\f147\";\n}\n.fa-level-up:before {\n  content: \"\\f148\";\n}\n.fa-level-down:before {\n  content: \"\\f149\";\n}\n.fa-check-square:before {\n  content: \"\\f14a\";\n}\n.fa-pencil-square:before {\n  content: \"\\f14b\";\n}\n.fa-external-link-square:before {\n  content: \"\\f14c\";\n}\n.fa-share-square:before {\n  content: \"\\f14d\";\n}\n.fa-compass:before {\n  content: \"\\f14e\";\n}\n.fa-toggle-down:before,\n.fa-caret-square-o-down:before {\n  content: \"\\f150\";\n}\n.fa-toggle-up:before,\n.fa-caret-square-o-up:before {\n  content: \"\\f151\";\n}\n.fa-toggle-right:before,\n.fa-caret-square-o-right:before {\n  content: \"\\f152\";\n}\n.fa-euro:before,\n.fa-eur:before {\n  content: \"\\f153\";\n}\n.fa-gbp:before {\n  content: \"\\f154\";\n}\n.fa-dollar:before,\n.fa-usd:before {\n  content: \"\\f155\";\n}\n.fa-rupee:before,\n.fa-inr:before {\n  content: \"\\f156\";\n}\n.fa-cny:before,\n.fa-rmb:before,\n.fa-yen:before,\n.fa-jpy:before {\n  content: \"\\f157\";\n}\n.fa-ruble:before,\n.fa-rouble:before,\n.fa-rub:before {\n  content: \"\\f158\";\n}\n.fa-won:before,\n.fa-krw:before {\n  content: \"\\f159\";\n}\n.fa-bitcoin:before,\n.fa-btc:before {\n  content: \"\\f15a\";\n}\n.fa-file:before {\n  content: \"\\f15b\";\n}\n.fa-file-text:before {\n  content: \"\\f15c\";\n}\n.fa-sort-alpha-asc:before {\n  content: \"\\f15d\";\n}\n.fa-sort-alpha-desc:before {\n  content: \"\\f15e\";\n}\n.fa-sort-amount-asc:before {\n  content: \"\\f160\";\n}\n.fa-sort-amount-desc:before {\n  content: \"\\f161\";\n}\n.fa-sort-numeric-asc:before {\n  content: \"\\f162\";\n}\n.fa-sort-numeric-desc:before {\n  content: \"\\f163\";\n}\n.fa-thumbs-up:before {\n  content: \"\\f164\";\n}\n.fa-thumbs-down:before {\n  content: \"\\f165\";\n}\n.fa-youtube-square:before {\n  content: \"\\f166\";\n}\n.fa-youtube:before {\n  content: \"\\f167\";\n}\n.fa-xing:before {\n  content: \"\\f168\";\n}\n.fa-xing-square:before {\n  content: \"\\f169\";\n}\n.fa-youtube-play:before {\n  content: \"\\f16a\";\n}\n.fa-dropbox:before {\n  content: \"\\f16b\";\n}\n.fa-stack-overflow:before {\n  content: \"\\f16c\";\n}\n.fa-instagram:before {\n  content: \"\\f16d\";\n}\n.fa-flickr:before {\n  content: \"\\f16e\";\n}\n.fa-adn:before {\n  content: \"\\f170\";\n}\n.fa-bitbucket:before {\n  content: \"\\f171\";\n}\n.fa-bitbucket-square:before {\n  content: \"\\f172\";\n}\n.fa-tumblr:before {\n  content: \"\\f173\";\n}\n.fa-tumblr-square:before {\n  content: \"\\f174\";\n}\n.fa-long-arrow-down:before {\n  content: \"\\f175\";\n}\n.fa-long-arrow-up:before {\n  content: \"\\f176\";\n}\n.fa-long-arrow-left:before {\n  content: \"\\f177\";\n}\n.fa-long-arrow-right:before {\n  content: \"\\f178\";\n}\n.fa-apple:before {\n  content: \"\\f179\";\n}\n.fa-windows:before {\n  content: \"\\f17a\";\n}\n.fa-android:before {\n  content: \"\\f17b\";\n}\n.fa-linux:before {\n  content: \"\\f17c\";\n}\n.fa-dribbble:before {\n  content: \"\\f17d\";\n}\n.fa-skype:before {\n  content: \"\\f17e\";\n}\n.fa-foursquare:before {\n  content: \"\\f180\";\n}\n.fa-trello:before {\n  content: \"\\f181\";\n}\n.fa-female:before {\n  content: \"\\f182\";\n}\n.fa-male:before {\n  content: \"\\f183\";\n}\n.fa-gittip:before,\n.fa-gratipay:before {\n  content: \"\\f184\";\n}\n.fa-sun-o:before {\n  content: \"\\f185\";\n}\n.fa-moon-o:before {\n  content: \"\\f186\";\n}\n.fa-archive:before {\n  content: \"\\f187\";\n}\n.fa-bug:before {\n  content: \"\\f188\";\n}\n.fa-vk:before {\n  content: \"\\f189\";\n}\n.fa-weibo:before {\n  content: \"\\f18a\";\n}\n.fa-renren:before {\n  content: \"\\f18b\";\n}\n.fa-pagelines:before {\n  content: \"\\f18c\";\n}\n.fa-stack-exchange:before {\n  content: \"\\f18d\";\n}\n.fa-arrow-circle-o-right:before {\n  content: \"\\f18e\";\n}\n.fa-arrow-circle-o-left:before {\n  content: \"\\f190\";\n}\n.fa-toggle-left:before,\n.fa-caret-square-o-left:before {\n  content: \"\\f191\";\n}\n.fa-dot-circle-o:before {\n  content: \"\\f192\";\n}\n.fa-wheelchair:before {\n  content: \"\\f193\";\n}\n.fa-vimeo-square:before {\n  content: \"\\f194\";\n}\n.fa-turkish-lira:before,\n.fa-try:before {\n  content: \"\\f195\";\n}\n.fa-plus-square-o:before {\n  content: \"\\f196\";\n}\n.fa-space-shuttle:before {\n  content: \"\\f197\";\n}\n.fa-slack:before {\n  content: \"\\f198\";\n}\n.fa-envelope-square:before {\n  content: \"\\f199\";\n}\n.fa-wordpress:before {\n  content: \"\\f19a\";\n}\n.fa-openid:before {\n  content: \"\\f19b\";\n}\n.fa-institution:before,\n.fa-bank:before,\n.fa-university:before {\n  content: \"\\f19c\";\n}\n.fa-mortar-board:before,\n.fa-graduation-cap:before {\n  content: \"\\f19d\";\n}\n.fa-yahoo:before {\n  content: \"\\f19e\";\n}\n.fa-google:before {\n  content: \"\\f1a0\";\n}\n.fa-reddit:before {\n  content: \"\\f1a1\";\n}\n.fa-reddit-square:before {\n  content: \"\\f1a2\";\n}\n.fa-stumbleupon-circle:before {\n  content: \"\\f1a3\";\n}\n.fa-stumbleupon:before {\n  content: \"\\f1a4\";\n}\n.fa-delicious:before {\n  content: \"\\f1a5\";\n}\n.fa-digg:before {\n  content: \"\\f1a6\";\n}\n.fa-pied-piper:before {\n  content: \"\\f1a7\";\n}\n.fa-pied-piper-alt:before {\n  content: \"\\f1a8\";\n}\n.fa-drupal:before {\n  content: \"\\f1a9\";\n}\n.fa-joomla:before {\n  content: \"\\f1aa\";\n}\n.fa-language:before {\n  content: \"\\f1ab\";\n}\n.fa-fax:before {\n  content: \"\\f1ac\";\n}\n.fa-building:before {\n  content: \"\\f1ad\";\n}\n.fa-child:before {\n  content: \"\\f1ae\";\n}\n.fa-paw:before {\n  content: \"\\f1b0\";\n}\n.fa-spoon:before {\n  content: \"\\f1b1\";\n}\n.fa-cube:before {\n  content: \"\\f1b2\";\n}\n.fa-cubes:before {\n  content: \"\\f1b3\";\n}\n.fa-behance:before {\n  content: \"\\f1b4\";\n}\n.fa-behance-square:before {\n  content: \"\\f1b5\";\n}\n.fa-steam:before {\n  content: \"\\f1b6\";\n}\n.fa-steam-square:before {\n  content: \"\\f1b7\";\n}\n.fa-recycle:before {\n  content: \"\\f1b8\";\n}\n.fa-automobile:before,\n.fa-car:before {\n  content: \"\\f1b9\";\n}\n.fa-cab:before,\n.fa-taxi:before {\n  content: \"\\f1ba\";\n}\n.fa-tree:before {\n  content: \"\\f1bb\";\n}\n.fa-spotify:before {\n  content: \"\\f1bc\";\n}\n.fa-deviantart:before {\n  content: \"\\f1bd\";\n}\n.fa-soundcloud:before {\n  content: \"\\f1be\";\n}\n.fa-database:before {\n  content: \"\\f1c0\";\n}\n.fa-file-pdf-o:before {\n  content: \"\\f1c1\";\n}\n.fa-file-word-o:before {\n  content: \"\\f1c2\";\n}\n.fa-file-excel-o:before {\n  content: \"\\f1c3\";\n}\n.fa-file-powerpoint-o:before {\n  content: \"\\f1c4\";\n}\n.fa-file-photo-o:before,\n.fa-file-picture-o:before,\n.fa-file-image-o:before {\n  content: \"\\f1c5\";\n}\n.fa-file-zip-o:before,\n.fa-file-archive-o:before {\n  content: \"\\f1c6\";\n}\n.fa-file-sound-o:before,\n.fa-file-audio-o:before {\n  content: \"\\f1c7\";\n}\n.fa-file-movie-o:before,\n.fa-file-video-o:before {\n  content: \"\\f1c8\";\n}\n.fa-file-code-o:before {\n  content: \"\\f1c9\";\n}\n.fa-vine:before {\n  content: \"\\f1ca\";\n}\n.fa-codepen:before {\n  content: \"\\f1cb\";\n}\n.fa-jsfiddle:before {\n  content: \"\\f1cc\";\n}\n.fa-life-bouy:before,\n.fa-life-buoy:before,\n.fa-life-saver:before,\n.fa-support:before,\n.fa-life-ring:before {\n  content: \"\\f1cd\";\n}\n.fa-circle-o-notch:before {\n  content: \"\\f1ce\";\n}\n.fa-ra:before,\n.fa-rebel:before {\n  content: \"\\f1d0\";\n}\n.fa-ge:before,\n.fa-empire:before {\n  content: \"\\f1d1\";\n}\n.fa-git-square:before {\n  content: \"\\f1d2\";\n}\n.fa-git:before {\n  content: \"\\f1d3\";\n}\n.fa-hacker-news:before {\n  content: \"\\f1d4\";\n}\n.fa-tencent-weibo:before {\n  content: \"\\f1d5\";\n}\n.fa-qq:before {\n  content: \"\\f1d6\";\n}\n.fa-wechat:before,\n.fa-weixin:before {\n  content: \"\\f1d7\";\n}\n.fa-send:before,\n.fa-paper-plane:before {\n  content: \"\\f1d8\";\n}\n.fa-send-o:before,\n.fa-paper-plane-o:before {\n  content: \"\\f1d9\";\n}\n.fa-history:before {\n  content: \"\\f1da\";\n}\n.fa-genderless:before,\n.fa-circle-thin:before {\n  content: \"\\f1db\";\n}\n.fa-header:before {\n  content: \"\\f1dc\";\n}\n.fa-paragraph:before {\n  content: \"\\f1dd\";\n}\n.fa-sliders:before {\n  content: \"\\f1de\";\n}\n.fa-share-alt:before {\n  content: \"\\f1e0\";\n}\n.fa-share-alt-square:before {\n  content: \"\\f1e1\";\n}\n.fa-bomb:before {\n  content: \"\\f1e2\";\n}\n.fa-soccer-ball-o:before,\n.fa-futbol-o:before {\n  content: \"\\f1e3\";\n}\n.fa-tty:before {\n  content: \"\\f1e4\";\n}\n.fa-binoculars:before {\n  content: \"\\f1e5\";\n}\n.fa-plug:before {\n  content: \"\\f1e6\";\n}\n.fa-slideshare:before {\n  content: \"\\f1e7\";\n}\n.fa-twitch:before {\n  content: \"\\f1e8\";\n}\n.fa-yelp:before {\n  content: \"\\f1e9\";\n}\n.fa-newspaper-o:before {\n  content: \"\\f1ea\";\n}\n.fa-wifi:before {\n  content: \"\\f1eb\";\n}\n.fa-calculator:before {\n  content: \"\\f1ec\";\n}\n.fa-paypal:before {\n  content: \"\\f1ed\";\n}\n.fa-google-wallet:before {\n  content: \"\\f1ee\";\n}\n.fa-cc-visa:before {\n  content: \"\\f1f0\";\n}\n.fa-cc-mastercard:before {\n  content: \"\\f1f1\";\n}\n.fa-cc-discover:before {\n  content: \"\\f1f2\";\n}\n.fa-cc-amex:before {\n  content: \"\\f1f3\";\n}\n.fa-cc-paypal:before {\n  content: \"\\f1f4\";\n}\n.fa-cc-stripe:before {\n  content: \"\\f1f5\";\n}\n.fa-bell-slash:before {\n  content: \"\\f1f6\";\n}\n.fa-bell-slash-o:before {\n  content: \"\\f1f7\";\n}\n.fa-trash:before {\n  content: \"\\f1f8\";\n}\n.fa-copyright:before {\n  content: \"\\f1f9\";\n}\n.fa-at:before {\n  content: \"\\f1fa\";\n}\n.fa-eyedropper:before {\n  content: \"\\f1fb\";\n}\n.fa-paint-brush:before {\n  content: \"\\f1fc\";\n}\n.fa-birthday-cake:before {\n  content: \"\\f1fd\";\n}\n.fa-area-chart:before {\n  content: \"\\f1fe\";\n}\n.fa-pie-chart:before {\n  content: \"\\f200\";\n}\n.fa-line-chart:before {\n  content: \"\\f201\";\n}\n.fa-lastfm:before {\n  content: \"\\f202\";\n}\n.fa-lastfm-square:before {\n  content: \"\\f203\";\n}\n.fa-toggle-off:before {\n  content: \"\\f204\";\n}\n.fa-toggle-on:before {\n  content: \"\\f205\";\n}\n.fa-bicycle:before {\n  content: \"\\f206\";\n}\n.fa-bus:before {\n  content: \"\\f207\";\n}\n.fa-ioxhost:before {\n  content: \"\\f208\";\n}\n.fa-angellist:before {\n  content: \"\\f209\";\n}\n.fa-cc:before {\n  content: \"\\f20a\";\n}\n.fa-shekel:before,\n.fa-sheqel:before,\n.fa-ils:before {\n  content: \"\\f20b\";\n}\n.fa-meanpath:before {\n  content: \"\\f20c\";\n}\n.fa-buysellads:before {\n  content: \"\\f20d\";\n}\n.fa-connectdevelop:before {\n  content: \"\\f20e\";\n}\n.fa-dashcube:before {\n  content: \"\\f210\";\n}\n.fa-forumbee:before {\n  content: \"\\f211\";\n}\n.fa-leanpub:before {\n  content: \"\\f212\";\n}\n.fa-sellsy:before {\n  content: \"\\f213\";\n}\n.fa-shirtsinbulk:before {\n  content: \"\\f214\";\n}\n.fa-simplybuilt:before {\n  content: \"\\f215\";\n}\n.fa-skyatlas:before {\n  content: \"\\f216\";\n}\n.fa-cart-plus:before {\n  content: \"\\f217\";\n}\n.fa-cart-arrow-down:before {\n  content: \"\\f218\";\n}\n.fa-diamond:before {\n  content: \"\\f219\";\n}\n.fa-ship:before {\n  content: \"\\f21a\";\n}\n.fa-user-secret:before {\n  content: \"\\f21b\";\n}\n.fa-motorcycle:before {\n  content: \"\\f21c\";\n}\n.fa-street-view:before {\n  content: \"\\f21d\";\n}\n.fa-heartbeat:before {\n  content: \"\\f21e\";\n}\n.fa-venus:before {\n  content: \"\\f221\";\n}\n.fa-mars:before {\n  content: \"\\f222\";\n}\n.fa-mercury:before {\n  content: \"\\f223\";\n}\n.fa-transgender:before {\n  content: \"\\f224\";\n}\n.fa-transgender-alt:before {\n  content: \"\\f225\";\n}\n.fa-venus-double:before {\n  content: \"\\f226\";\n}\n.fa-mars-double:before {\n  content: \"\\f227\";\n}\n.fa-venus-mars:before {\n  content: \"\\f228\";\n}\n.fa-mars-stroke:before {\n  content: \"\\f229\";\n}\n.fa-mars-stroke-v:before {\n  content: \"\\f22a\";\n}\n.fa-mars-stroke-h:before {\n  content: \"\\f22b\";\n}\n.fa-neuter:before {\n  content: \"\\f22c\";\n}\n.fa-facebook-official:before {\n  content: \"\\f230\";\n}\n.fa-pinterest-p:before {\n  content: \"\\f231\";\n}\n.fa-whatsapp:before {\n  content: \"\\f232\";\n}\n.fa-server:before {\n  content: \"\\f233\";\n}\n.fa-user-plus:before {\n  content: \"\\f234\";\n}\n.fa-user-times:before {\n  content: \"\\f235\";\n}\n.fa-hotel:before,\n.fa-bed:before {\n  content: \"\\f236\";\n}\n.fa-viacoin:before {\n  content: \"\\f237\";\n}\n.fa-train:before {\n  content: \"\\f238\";\n}\n.fa-subway:before {\n  content: \"\\f239\";\n}\n.fa-medium:before {\n  content: \"\\f23a\";\n}\n","// Core variables and mixins\r\n@import \"variables.less\";\r\n@import \"mixins.less\";\r\n\r\n// Core CSS\r\n.layout-editor {\r\n    @import \"scaffolding.less\";\r\n    @import \"grid.less\";\r\n}\r\n \r\n// Utility classes\r\n@import \"utilities.less\";\r\n","// Vendor Prefixes\r\n//\r\n// All vendor mixins are deprecated as of v3.2.0 due to the introduction of\r\n// Autoprefixer in our Gruntfile. They will be removed in v4.\r\n\r\n// - Animations\r\n// - Backface visibility\r\n// - Box shadow\r\n// - Box sizing\r\n// - Content columns\r\n// - Hyphens\r\n// - Placeholder text\r\n// - Transformations\r\n// - Transitions\r\n// - User Select\r\n\r\n\r\n// Animations\r\n.animation(@animation) {\r\n  -webkit-animation: @animation;\r\n       -o-animation: @animation;\r\n          animation: @animation;\r\n}\r\n.animation-name(@name) {\r\n  -webkit-animation-name: @name;\r\n          animation-name: @name;\r\n}\r\n.animation-duration(@duration) {\r\n  -webkit-animation-duration: @duration;\r\n          animation-duration: @duration;\r\n}\r\n.animation-timing-function(@timing-function) {\r\n  -webkit-animation-timing-function: @timing-function;\r\n          animation-timing-function: @timing-function;\r\n}\r\n.animation-delay(@delay) {\r\n  -webkit-animation-delay: @delay;\r\n          animation-delay: @delay;\r\n}\r\n.animation-iteration-count(@iteration-count) {\r\n  -webkit-animation-iteration-count: @iteration-count;\r\n          animation-iteration-count: @iteration-count;\r\n}\r\n.animation-direction(@direction) {\r\n  -webkit-animation-direction: @direction;\r\n          animation-direction: @direction;\r\n}\r\n.animation-fill-mode(@fill-mode) {\r\n  -webkit-animation-fill-mode: @fill-mode;\r\n          animation-fill-mode: @fill-mode;\r\n}\r\n\r\n// Backface visibility\r\n// Prevent browsers from flickering when using CSS 3D transforms.\r\n// Default value is `visible`, but can be changed to `hidden`\r\n\r\n.backface-visibility(@visibility){\r\n  -webkit-backface-visibility: @visibility;\r\n     -moz-backface-visibility: @visibility;\r\n          backface-visibility: @visibility;\r\n}\r\n\r\n// Drop shadows\r\n//\r\n// Note: Deprecated `.box-shadow()` as of v3.1.0 since all of Bootstrap's\r\n// supported browsers that have box shadow capabilities now support it.\r\n\r\n.box-shadow(@shadow) {\r\n  -webkit-box-shadow: @shadow; // iOS <4.3 & Android <4.1\r\n          box-shadow: @shadow;\r\n}\r\n\r\n// Box sizing\r\n.box-sizing(@boxmodel) {\r\n  -webkit-box-sizing: @boxmodel;\r\n     -moz-box-sizing: @boxmodel;\r\n          box-sizing: @boxmodel;\r\n}\r\n\r\n// CSS3 Content Columns\r\n.content-columns(@column-count; @column-gap: @grid-gutter-width) {\r\n  -webkit-column-count: @column-count;\r\n     -moz-column-count: @column-count;\r\n          column-count: @column-count;\r\n  -webkit-column-gap: @column-gap;\r\n     -moz-column-gap: @column-gap;\r\n          column-gap: @column-gap;\r\n}\r\n\r\n// Optional hyphenation\r\n.hyphens(@mode: auto) {\r\n  word-wrap: break-word;\r\n  -webkit-hyphens: @mode;\r\n     -moz-hyphens: @mode;\r\n      -ms-hyphens: @mode; // IE10+\r\n       -o-hyphens: @mode;\r\n          hyphens: @mode;\r\n}\r\n\r\n// Placeholder text\r\n.placeholder(@color: @input-color-placeholder) {\r\n  // Firefox\r\n  &::-moz-placeholder {\r\n    color: @color;\r\n    opacity: 1; // See https://github.com/twbs/bootstrap/pull/11526\r\n  }\r\n  &:-ms-input-placeholder { color: @color; } // Internet Explorer 10+\r\n  &::-webkit-input-placeholder  { color: @color; } // Safari and Chrome\r\n}\r\n\r\n// Transformations\r\n.scale(@ratio) {\r\n  -webkit-transform: scale(@ratio);\r\n      -ms-transform: scale(@ratio); // IE9 only\r\n       -o-transform: scale(@ratio);\r\n          transform: scale(@ratio);\r\n}\r\n.scale(@ratioX; @ratioY) {\r\n  -webkit-transform: scale(@ratioX, @ratioY);\r\n      -ms-transform: scale(@ratioX, @ratioY); // IE9 only\r\n       -o-transform: scale(@ratioX, @ratioY);\r\n          transform: scale(@ratioX, @ratioY);\r\n}\r\n.scaleX(@ratio) {\r\n  -webkit-transform: scaleX(@ratio);\r\n      -ms-transform: scaleX(@ratio); // IE9 only\r\n       -o-transform: scaleX(@ratio);\r\n          transform: scaleX(@ratio);\r\n}\r\n.scaleY(@ratio) {\r\n  -webkit-transform: scaleY(@ratio);\r\n      -ms-transform: scaleY(@ratio); // IE9 only\r\n       -o-transform: scaleY(@ratio);\r\n          transform: scaleY(@ratio);\r\n}\r\n.skew(@x; @y) {\r\n  -webkit-transform: skewX(@x) skewY(@y);\r\n      -ms-transform: skewX(@x) skewY(@y); // See https://github.com/twbs/bootstrap/issues/4885; IE9+\r\n       -o-transform: skewX(@x) skewY(@y);\r\n          transform: skewX(@x) skewY(@y);\r\n}\r\n.translate(@x; @y) {\r\n  -webkit-transform: translate(@x, @y);\r\n      -ms-transform: translate(@x, @y); // IE9 only\r\n       -o-transform: translate(@x, @y);\r\n          transform: translate(@x, @y);\r\n}\r\n.translate3d(@x; @y; @z) {\r\n  -webkit-transform: translate3d(@x, @y, @z);\r\n          transform: translate3d(@x, @y, @z);\r\n}\r\n.rotate(@degrees) {\r\n  -webkit-transform: rotate(@degrees);\r\n      -ms-transform: rotate(@degrees); // IE9 only\r\n       -o-transform: rotate(@degrees);\r\n          transform: rotate(@degrees);\r\n}\r\n.rotateX(@degrees) {\r\n  -webkit-transform: rotateX(@degrees);\r\n      -ms-transform: rotateX(@degrees); // IE9 only\r\n       -o-transform: rotateX(@degrees);\r\n          transform: rotateX(@degrees);\r\n}\r\n.rotateY(@degrees) {\r\n  -webkit-transform: rotateY(@degrees);\r\n      -ms-transform: rotateY(@degrees); // IE9 only\r\n       -o-transform: rotateY(@degrees);\r\n          transform: rotateY(@degrees);\r\n}\r\n.perspective(@perspective) {\r\n  -webkit-perspective: @perspective;\r\n     -moz-perspective: @perspective;\r\n          perspective: @perspective;\r\n}\r\n.perspective-origin(@perspective) {\r\n  -webkit-perspective-origin: @perspective;\r\n     -moz-perspective-origin: @perspective;\r\n          perspective-origin: @perspective;\r\n}\r\n.transform-origin(@origin) {\r\n  -webkit-transform-origin: @origin;\r\n     -moz-transform-origin: @origin;\r\n      -ms-transform-origin: @origin; // IE9 only\r\n          transform-origin: @origin;\r\n}\r\n\r\n\r\n// Transitions\r\n\r\n.transition(@transition) {\r\n  -webkit-transition: @transition;\r\n       -o-transition: @transition;\r\n          transition: @transition;\r\n}\r\n.transition-property(@transition-property) {\r\n  -webkit-transition-property: @transition-property;\r\n          transition-property: @transition-property;\r\n}\r\n.transition-delay(@transition-delay) {\r\n  -webkit-transition-delay: @transition-delay;\r\n          transition-delay: @transition-delay;\r\n}\r\n.transition-duration(@transition-duration) {\r\n  -webkit-transition-duration: @transition-duration;\r\n          transition-duration: @transition-duration;\r\n}\r\n.transition-timing-function(@timing-function) {\r\n  -webkit-transition-timing-function: @timing-function;\r\n          transition-timing-function: @timing-function;\r\n}\r\n.transition-transform(@transition) {\r\n  -webkit-transition: -webkit-transform @transition;\r\n     -moz-transition: -moz-transform @transition;\r\n       -o-transition: -o-transform @transition;\r\n          transition: transform @transition;\r\n}\r\n\r\n\r\n// User select\r\n// For selecting text on the page\r\n\r\n.user-select(@select) {\r\n  -webkit-user-select: @select;\r\n     -moz-user-select: @select;\r\n      -ms-user-select: @select; // IE10+\r\n          user-select: @select;\r\n}\r\n","//\r\n// Scaffolding\r\n// --------------------------------------------------\r\n\r\n\r\n// Reset the box-sizing\r\n//\r\n// Heads up! This reset may cause conflicts with some third-party widgets.\r\n// For recommendations on resolving such conflicts, see\r\n// http://getbootstrap.com/getting-started/#third-box-sizing\r\n* {\r\n  .box-sizing(border-box);\r\n}\r\n*:before,\r\n*:after {\r\n  .box-sizing(border-box);\r\n}\r\n\r\n\r\n// Body reset\r\n\r\nhtml {\r\n  font-size: 10px;\r\n  -webkit-tap-highlight-color: rgba(0,0,0,0);\r\n}\r\n\r\nbody {\r\n  font-family: @font-family-base;\r\n  font-size: @font-size-base;\r\n  line-height: @line-height-base;\r\n  color: @text-color;\r\n  background-color: @body-bg;\r\n}\r\n\r\n// Reset fonts for relevant elements\r\ninput,\r\nbutton,\r\nselect,\r\ntextarea {\r\n  font-family: inherit;\r\n  font-size: inherit;\r\n  line-height: inherit;\r\n}\r\n\r\n\r\n// Links\r\n\r\na {\r\n  color: @link-color;\r\n  text-decoration: none;\r\n\r\n  &:hover,\r\n  &:focus {\r\n    color: @link-hover-color;\r\n    text-decoration: @link-hover-decoration;\r\n  }\r\n\r\n  &:focus {\r\n    .tab-focus();\r\n  }\r\n}\r\n\r\n\r\n// Figures\r\n//\r\n// We reset this here because previously Normalize had no `figure` margins. This\r\n// ensures we don't break anyone's use of the element.\r\n\r\nfigure {\r\n  margin: 0;\r\n}\r\n\r\n\r\n// Images\r\n\r\nimg {\r\n  vertical-align: middle;\r\n}\r\n\r\n// Responsive images (ensure images don't scale beyond their parents)\r\n.img-responsive {\r\n  .img-responsive();\r\n}\r\n\r\n// Rounded corners\r\n.img-rounded {\r\n  border-radius: @border-radius-large;\r\n}\r\n\r\n// Image thumbnails\r\n//\r\n// Heads up! This is mixin-ed into thumbnails.less for `.thumbnail`.\r\n.img-thumbnail {\r\n  padding: @thumbnail-padding;\r\n  line-height: @line-height-base;\r\n  background-color: @thumbnail-bg;\r\n  border: 1px solid @thumbnail-border;\r\n  border-radius: @thumbnail-border-radius;\r\n  .transition(all .2s ease-in-out);\r\n\r\n  // Keep them at most 100% wide\r\n  .img-responsive(inline-block);\r\n}\r\n\r\n// Perfect circle\r\n.img-circle {\r\n  border-radius: 50%; // set radius in percents\r\n}\r\n\r\n\r\n// Horizontal rules\r\n\r\nhr {\r\n  margin-top:    @line-height-computed;\r\n  margin-bottom: @line-height-computed;\r\n  border: 0;\r\n  border-top: 1px solid @hr-border;\r\n}\r\n\r\n\r\n// Only display content to screen readers\r\n//\r\n// See: http://a11yproject.com/posts/how-to-hide-content/\r\n\r\n.sr-only {\r\n  position: absolute;\r\n  width: 1px;\r\n  height: 1px;\r\n  margin: -1px;\r\n  padding: 0;\r\n  overflow: hidden;\r\n  clip: rect(0,0,0,0);\r\n  border: 0;\r\n}\r\n\r\n// Use in conjunction with .sr-only to only display content when it's focused.\r\n// Useful for \"Skip to main content\" links; see http://www.w3.org/TR/2013/NOTE-WCAG20-TECHS-20130905/G1\r\n// Credit: HTML5 Boilerplate\r\n\r\n.sr-only-focusable {\r\n  &:active,\r\n  &:focus {\r\n    position: static;\r\n    width: auto;\r\n    height: auto;\r\n    margin: 0;\r\n    overflow: visible;\r\n    clip: auto;\r\n  }\r\n}\r\n","// WebKit-style focus\r\n\r\n.tab-focus() {\r\n  // Default\r\n  outline: thin dotted;\r\n  // WebKit\r\n  outline: 5px auto -webkit-focus-ring-color;\r\n  outline-offset: -2px;\r\n}\r\n","// Image Mixins\r\n// - Responsive image\r\n// - Retina image\r\n\r\n\r\n// Responsive image\r\n//\r\n// Keep images from scaling beyond the width of their parents.\r\n.img-responsive(@display: block) {\r\n  display: @display;\r\n  max-width: 100%; // Part 1: Set a maximum relative to the parent\r\n  height: auto; // Part 2: Scale the height according to the width, otherwise you get stretching\r\n}\r\n\r\n\r\n// Retina image\r\n//\r\n// Short retina mixin for setting background-image and -size. Note that the\r\n// spelling of `min--moz-device-pixel-ratio` is intentional.\r\n.img-retina(@file-1x; @file-2x; @width-1x; @height-1x) {\r\n  background-image: url(\"@{file-1x}\");\r\n\r\n  @media\r\n  only screen and (-webkit-min-device-pixel-ratio: 2),\r\n  only screen and (   min--moz-device-pixel-ratio: 2),\r\n  only screen and (     -o-min-device-pixel-ratio: 2/1),\r\n  only screen and (        min-device-pixel-ratio: 2),\r\n  only screen and (                min-resolution: 192dpi),\r\n  only screen and (                min-resolution: 2dppx) {\r\n    background-image: url(\"@{file-2x}\");\r\n    background-size: @width-1x @height-1x;\r\n  }\r\n}\r\n","// Grid system\r\n//\r\n// Generate semantic grid columns with these mixins.\r\n\r\n// Centered container element\r\n.container-fixed(@gutter: @grid-gutter-width) {\r\n  margin-right: auto;\r\n  margin-left: auto;\r\n  padding-left:  (@gutter / 2);\r\n  padding-right: (@gutter / 2);\r\n  &:extend(.clearfix all);\r\n}\r\n\r\n// Creates a wrapper for a series of columns\r\n.make-row(@gutter: @grid-gutter-width) {\r\n  margin-left:  (@gutter / -2);\r\n  margin-right: (@gutter / -2);\r\n  &:extend(.clearfix all);\r\n}\r\n\r\n// Generate the extra small columns\r\n.make-xs-column(@columns; @gutter: @grid-gutter-width) {\r\n  position: relative;\r\n  float: left;\r\n  width: percentage((@columns / @grid-columns));\r\n  min-height: 1px;\r\n  padding-left:  (@gutter / 2);\r\n  padding-right: (@gutter / 2);\r\n}\r\n.make-xs-column-offset(@columns) {\r\n  margin-left: percentage((@columns / @grid-columns));\r\n}\r\n.make-xs-column-push(@columns) {\r\n  left: percentage((@columns / @grid-columns));\r\n}\r\n.make-xs-column-pull(@columns) {\r\n  right: percentage((@columns / @grid-columns));\r\n}\r\n\r\n// Generate the small columns\r\n.make-sm-column(@columns; @gutter: @grid-gutter-width) {\r\n  position: relative;\r\n  min-height: 1px;\r\n  padding-left:  (@gutter / 2);\r\n  padding-right: (@gutter / 2);\r\n\r\n  @media (min-width: @screen-sm-min) {\r\n    float: left;\r\n    width: percentage((@columns / @grid-columns));\r\n  }\r\n}\r\n.make-sm-column-offset(@columns) {\r\n  @media (min-width: @screen-sm-min) {\r\n    margin-left: percentage((@columns / @grid-columns));\r\n  }\r\n}\r\n.make-sm-column-push(@columns) {\r\n  @media (min-width: @screen-sm-min) {\r\n    left: percentage((@columns / @grid-columns));\r\n  }\r\n}\r\n.make-sm-column-pull(@columns) {\r\n  @media (min-width: @screen-sm-min) {\r\n    right: percentage((@columns / @grid-columns));\r\n  }\r\n}\r\n\r\n// Generate the medium columns\r\n.make-md-column(@columns; @gutter: @grid-gutter-width) {\r\n  position: relative;\r\n  min-height: 1px;\r\n  padding-left:  (@gutter / 2);\r\n  padding-right: (@gutter / 2);\r\n\r\n  @media (min-width: @screen-md-min) {\r\n    float: left;\r\n    width: percentage((@columns / @grid-columns));\r\n  }\r\n}\r\n.make-md-column-offset(@columns) {\r\n  @media (min-width: @screen-md-min) {\r\n    margin-left: percentage((@columns / @grid-columns));\r\n  }\r\n}\r\n.make-md-column-push(@columns) {\r\n  @media (min-width: @screen-md-min) {\r\n    left: percentage((@columns / @grid-columns));\r\n  }\r\n}\r\n.make-md-column-pull(@columns) {\r\n  @media (min-width: @screen-md-min) {\r\n    right: percentage((@columns / @grid-columns));\r\n  }\r\n}\r\n\r\n// Generate the large columns\r\n.make-lg-column(@columns; @gutter: @grid-gutter-width) {\r\n  position: relative;\r\n  min-height: 1px;\r\n  padding-left:  (@gutter / 2);\r\n  padding-right: (@gutter / 2);\r\n\r\n  @media (min-width: @screen-lg-min) {\r\n    float: left;\r\n    width: percentage((@columns / @grid-columns));\r\n  }\r\n}\r\n.make-lg-column-offset(@columns) {\r\n  @media (min-width: @screen-lg-min) {\r\n    margin-left: percentage((@columns / @grid-columns));\r\n  }\r\n}\r\n.make-lg-column-push(@columns) {\r\n  @media (min-width: @screen-lg-min) {\r\n    left: percentage((@columns / @grid-columns));\r\n  }\r\n}\r\n.make-lg-column-pull(@columns) {\r\n  @media (min-width: @screen-lg-min) {\r\n    right: percentage((@columns / @grid-columns));\r\n  }\r\n}\r\n","//\r\n// Grid system\r\n// --------------------------------------------------\r\n\r\n\r\n// Container widths\r\n//\r\n// Set the container width, and override it for fixed navbars in media queries.\r\n\r\n.container {\r\n  .container-fixed();\r\n\r\n  @media (min-width: @screen-sm-min) {\r\n    width: @container-sm;\r\n  }\r\n  @media (min-width: @screen-md-min) {\r\n    width: @container-md;\r\n  }\r\n  @media (min-width: @screen-lg-min) {\r\n    width: @container-lg;\r\n  }\r\n}\r\n\r\n\r\n// Fluid container\r\n//\r\n// Utilizes the mixin meant for fixed width containers, but without any defined\r\n// width for fluid, full width layouts.\r\n\r\n.container-fluid {\r\n  .container-fixed();\r\n}\r\n\r\n\r\n// Row\r\n//\r\n// Rows contain and clear the floats of your columns.\r\n\r\n.row {\r\n  .make-row();\r\n}\r\n\r\n\r\n// Columns\r\n//\r\n// Common styles for small and large grid columns\r\n\r\n.make-grid-columns();\r\n\r\n\r\n// Extra small grid\r\n//\r\n// Columns, offsets, pushes, and pulls for extra small devices like\r\n// smartphones.\r\n\r\n.make-grid(xs);\r\n\r\n\r\n// Small grid\r\n//\r\n// Columns, offsets, pushes, and pulls for the small device range, from phones\r\n// to tablets.\r\n\r\n@media (min-width: @screen-sm-min) {\r\n  .make-grid(sm);\r\n}\r\n\r\n\r\n// Medium grid\r\n//\r\n// Columns, offsets, pushes, and pulls for the desktop device range.\r\n\r\n@media (min-width: @screen-md-min) {\r\n  .make-grid(md);\r\n}\r\n\r\n\r\n// Large grid\r\n//\r\n// Columns, offsets, pushes, and pulls for the large desktop device range.\r\n\r\n@media (min-width: @screen-lg-min) {\r\n  .make-grid(lg);\r\n}\r\n","// Framework grid generation\r\n//\r\n// Used only by Bootstrap to generate the correct number of grid classes given\r\n// any value of `@grid-columns`.\r\n\r\n.make-grid-columns() {\r\n  // Common styles for all sizes of grid columns, widths 1-12\r\n  .col(@index) { // initial\r\n    @item: ~\".col-xs-@{index}, .col-sm-@{index}, .col-md-@{index}, .col-lg-@{index}\";\r\n    .col((@index + 1), @item);\r\n  }\r\n  .col(@index, @list) when (@index =< @grid-columns) { // general; \"=<\" isn't a typo\r\n    @item: ~\".col-xs-@{index}, .col-sm-@{index}, .col-md-@{index}, .col-lg-@{index}\";\r\n    .col((@index + 1), ~\"@{list}, @{item}\");\r\n  }\r\n  .col(@index, @list) when (@index > @grid-columns) { // terminal\r\n    @{list} {\r\n      position: relative;\r\n      // Prevent columns from collapsing when empty\r\n      min-height: 1px;\r\n      // Inner gutter via padding\r\n      padding-left:  (@grid-gutter-width / 2);\r\n      padding-right: (@grid-gutter-width / 2);\r\n    }\r\n  }\r\n  .col(1); // kickstart it\r\n}\r\n\r\n.float-grid-columns(@class) {\r\n  .col(@index) { // initial\r\n    @item: ~\".col-@{class}-@{index}\";\r\n    .col((@index + 1), @item);\r\n  }\r\n  .col(@index, @list) when (@index =< @grid-columns) { // general\r\n    @item: ~\".col-@{class}-@{index}\";\r\n    .col((@index + 1), ~\"@{list}, @{item}\");\r\n  }\r\n  .col(@index, @list) when (@index > @grid-columns) { // terminal\r\n    @{list} {\r\n      float: left;\r\n    }\r\n  }\r\n  .col(1); // kickstart it\r\n}\r\n\r\n.calc-grid-column(@index, @class, @type) when (@type = width) and (@index > 0) {\r\n  .col-@{class}-@{index} {\r\n    width: percentage((@index / @grid-columns));\r\n  }\r\n}\r\n.calc-grid-column(@index, @class, @type) when (@type = push) and (@index > 0) {\r\n  .col-@{class}-push-@{index} {\r\n    left: percentage((@index / @grid-columns));\r\n  }\r\n}\r\n.calc-grid-column(@index, @class, @type) when (@type = push) and (@index = 0) {\r\n  .col-@{class}-push-0 {\r\n    left: auto;\r\n  }\r\n}\r\n.calc-grid-column(@index, @class, @type) when (@type = pull) and (@index > 0) {\r\n  .col-@{class}-pull-@{index} {\r\n    right: percentage((@index / @grid-columns));\r\n  }\r\n}\r\n.calc-grid-column(@index, @class, @type) when (@type = pull) and (@index = 0) {\r\n  .col-@{class}-pull-0 {\r\n    right: auto;\r\n  }\r\n}\r\n.calc-grid-column(@index, @class, @type) when (@type = offset) {\r\n  .col-@{class}-offset-@{index} {\r\n    margin-left: percentage((@index / @grid-columns));\r\n  }\r\n}\r\n\r\n// Basic looping in LESS\r\n.loop-grid-columns(@index, @class, @type) when (@index >= 0) {\r\n  .calc-grid-column(@index, @class, @type);\r\n  // next iteration\r\n  .loop-grid-columns((@index - 1), @class, @type);\r\n}\r\n\r\n// Create grid for specific class\r\n.make-grid(@class) {\r\n  .float-grid-columns(@class);\r\n  .loop-grid-columns(@grid-columns, @class, width);\r\n  .loop-grid-columns(@grid-columns, @class, pull);\r\n  .loop-grid-columns(@grid-columns, @class, push);\r\n  .loop-grid-columns(@grid-columns, @class, offset);\r\n}\r\n","// Clearfix\r\n//\r\n// For modern browsers\r\n// 1. The space content is one way to avoid an Opera bug when the\r\n//    contenteditable attribute is included anywhere else in the document.\r\n//    Otherwise it causes space to appear at the top and bottom of elements\r\n//    that are clearfixed.\r\n// 2. The use of `table` rather than `block` is only necessary if using\r\n//    `:before` to contain the top-margins of child elements.\r\n//\r\n// Source: http://nicolasgallagher.com/micro-clearfix-hack/\r\n\r\n.clearfix() {\r\n  &:before,\r\n  &:after {\r\n    content: \" \"; // 1\r\n    display: table; // 2\r\n  }\r\n  &:after {\r\n    clear: both;\r\n  }\r\n}\r\n","//\r\n// Utility classes\r\n// --------------------------------------------------\r\n\r\n\r\n// Floats\r\n// -------------------------\r\n\r\n.clearfix {\r\n  .clearfix();\r\n}\r\n.center-block {\r\n  .center-block();\r\n}\r\n.pull-right {\r\n  float: right !important;\r\n}\r\n.pull-left {\r\n  float: left !important;\r\n}\r\n\r\n\r\n// Toggling content\r\n// -------------------------\r\n\r\n// Note: Deprecated .hide in favor of .hidden or .sr-only (as appropriate) in v3.0.1\r\n.hide {\r\n  display: none !important;\r\n}\r\n.show {\r\n  display: block !important;\r\n}\r\n.invisible {\r\n  visibility: hidden;\r\n}\r\n.text-hide {\r\n  .text-hide();\r\n}\r\n\r\n\r\n// Hide from screenreaders and browsers\r\n//\r\n// Credit: HTML5 Boilerplate\r\n\r\n.hidden {\r\n  display: none !important;\r\n  visibility: hidden !important;\r\n}\r\n\r\n\r\n// For Affix plugin\r\n// -------------------------\r\n\r\n.affix {\r\n  position: fixed;\r\n}\r\n","// Center-align a block level element\r\n\r\n.center-block() {\r\n  display: block;\r\n  margin-left: auto;\r\n  margin-right: auto;\r\n}\r\n","// CSS image replacement\r\n//\r\n// Heads up! v3 launched with with only `.hide-text()`, but per our pattern for\r\n// mixins being reused as classes with the same name, this doesn't hold up. As\r\n// of v3.0.1 we have added `.text-hide()` and deprecated `.hide-text()`.\r\n//\r\n// Source: https://github.com/h5bp/html5-boilerplate/commit/aa0396eae757\r\n\r\n// Deprecated as of v3.0.1 (will be removed in v4)\r\n.hide-text() {\r\n  font: ~\"0/0\" a;\r\n  color: transparent;\r\n  text-shadow: none;\r\n  background-color: transparent;\r\n  border: 0;\r\n}\r\n\r\n// New mixin to use as of v3.0.1\r\n.text-hide() {\r\n  .hide-text();\r\n}\r\n","/* FONT PATH\r\n * -------------------------- */\r\n\r\n@font-face {\r\n  font-family: 'FontAwesome';\r\n  src: url('@{fa-font-path}/fontawesome-webfont.eot?v=@{fa-version}');\r\n  src: url('@{fa-font-path}/fontawesome-webfont.eot?#iefix&v=@{fa-version}') format('embedded-opentype'),\r\n    url('@{fa-font-path}/fontawesome-webfont.woff2?v=@{fa-version}') format('woff2'),\r\n    url('@{fa-font-path}/fontawesome-webfont.woff?v=@{fa-version}') format('woff'),\r\n    url('@{fa-font-path}/fontawesome-webfont.ttf?v=@{fa-version}') format('truetype'),\r\n    url('@{fa-font-path}/fontawesome-webfont.svg?v=@{fa-version}#fontawesomeregular') format('svg');\r\n//  src: url('@{fa-font-path}/FontAwesome.otf') format('opentype'); // used when developing fonts\r\n  font-weight: normal;\r\n  font-style: normal;\r\n}\r\n","// Base Class Definition\r\n// -------------------------\r\n\r\n.@{fa-css-prefix} {\r\n  display: inline-block;\r\n  font: normal normal normal @fa-font-size-base/1 FontAwesome; // shortening font declaration\r\n  font-size: inherit; // can't have font-size inherit on line above, so need to override\r\n  text-rendering: auto; // optimizelegibility throws things off #1094\r\n  -webkit-font-smoothing: antialiased;\r\n  -moz-osx-font-smoothing: grayscale;\r\n  transform: translate(0, 0); // ensures no half-pixel rendering in firefox\r\n\r\n}\r\n","// Icon Sizes\r\n// -------------------------\r\n\r\n/* makes the font 33% larger relative to the icon container */\r\n.@{fa-css-prefix}-lg {\r\n  font-size: (4em / 3);\r\n  line-height: (3em / 4);\r\n  vertical-align: -15%;\r\n}\r\n.@{fa-css-prefix}-2x { font-size: 2em; }\r\n.@{fa-css-prefix}-3x { font-size: 3em; }\r\n.@{fa-css-prefix}-4x { font-size: 4em; }\r\n.@{fa-css-prefix}-5x { font-size: 5em; }\r\n","// Fixed Width Icons\r\n// -------------------------\r\n.@{fa-css-prefix}-fw {\r\n  width: (18em / 14);\r\n  text-align: center;\r\n}\r\n","// List Icons\r\n// -------------------------\r\n\r\n.@{fa-css-prefix}-ul {\r\n  padding-left: 0;\r\n  margin-left: @fa-li-width;\r\n  list-style-type: none;\r\n  > li { position: relative; }\r\n}\r\n.@{fa-css-prefix}-li {\r\n  position: absolute;\r\n  left: -@fa-li-width;\r\n  width: @fa-li-width;\r\n  top: (2em / 14);\r\n  text-align: center;\r\n  &.@{fa-css-prefix}-lg {\r\n    left: (-@fa-li-width + (4em / 14));\r\n  }\r\n}\r\n","// Bordered & Pulled\r\n// -------------------------\r\n\r\n.@{fa-css-prefix}-border {\r\n  padding: .2em .25em .15em;\r\n  border: solid .08em @fa-border-color;\r\n  border-radius: .1em;\r\n}\r\n\r\n.pull-right { float: right; }\r\n.pull-left { float: left; }\r\n\r\n.@{fa-css-prefix} {\r\n  &.pull-left { margin-right: .3em; }\r\n  &.pull-right { margin-left: .3em; }\r\n}\r\n","// Animated Icons\r\n// --------------------------\r\n\r\n.@{fa-css-prefix}-spin {\r\n  -webkit-animation: fa-spin 2s infinite linear;\r\n          animation: fa-spin 2s infinite linear;\r\n}\r\n\r\n.@{fa-css-prefix}-pulse {\r\n  -webkit-animation: fa-spin 1s infinite steps(8);\r\n          animation: fa-spin 1s infinite steps(8);\r\n}\r\n\r\n@-webkit-keyframes fa-spin {\r\n  0% {\r\n    -webkit-transform: rotate(0deg);\r\n            transform: rotate(0deg);\r\n  }\r\n  100% {\r\n    -webkit-transform: rotate(359deg);\r\n            transform: rotate(359deg);\r\n  }\r\n}\r\n\r\n@keyframes fa-spin {\r\n  0% {\r\n    -webkit-transform: rotate(0deg);\r\n            transform: rotate(0deg);\r\n  }\r\n  100% {\r\n    -webkit-transform: rotate(359deg);\r\n            transform: rotate(359deg);\r\n  }\r\n}\r\n","// Rotated & Flipped Icons\r\n// -------------------------\r\n\r\n.@{fa-css-prefix}-rotate-90  { .fa-icon-rotate(90deg, 1);  }\r\n.@{fa-css-prefix}-rotate-180 { .fa-icon-rotate(180deg, 2); }\r\n.@{fa-css-prefix}-rotate-270 { .fa-icon-rotate(270deg, 3); }\r\n\r\n.@{fa-css-prefix}-flip-horizontal { .fa-icon-flip(-1, 1, 0); }\r\n.@{fa-css-prefix}-flip-vertical   { .fa-icon-flip(1, -1, 2); }\r\n\r\n// Hook for IE8-9\r\n// -------------------------\r\n\r\n:root .@{fa-css-prefix}-rotate-90,\r\n:root .@{fa-css-prefix}-rotate-180,\r\n:root .@{fa-css-prefix}-rotate-270,\r\n:root .@{fa-css-prefix}-flip-horizontal,\r\n:root .@{fa-css-prefix}-flip-vertical {\r\n  filter: none;\r\n}\r\n","// Mixins\r\n// --------------------------\r\n\r\n.fa-icon() {\r\n  display: inline-block;\r\n  font: normal normal normal @fa-font-size-base/1 FontAwesome; // shortening font declaration\r\n  font-size: inherit; // can't have font-size inherit on line above, so need to override\r\n  text-rendering: auto; // optimizelegibility throws things off #1094\r\n  -webkit-font-smoothing: antialiased;\r\n  -moz-osx-font-smoothing: grayscale;\r\n  transform: translate(0, 0); // ensures no half-pixel rendering in firefox\r\n\r\n}\r\n\r\n.fa-icon-rotate(@degrees, @rotation) {\r\n  filter: progid:DXImageTransform.Microsoft.BasicImage(rotation=@rotation);\r\n  -webkit-transform: rotate(@degrees);\r\n      -ms-transform: rotate(@degrees);\r\n          transform: rotate(@degrees);\r\n}\r\n\r\n.fa-icon-flip(@horiz, @vert, @rotation) {\r\n  filter: progid:DXImageTransform.Microsoft.BasicImage(rotation=@rotation, mirror=1);\r\n  -webkit-transform: scale(@horiz, @vert);\r\n      -ms-transform: scale(@horiz, @vert);\r\n          transform: scale(@horiz, @vert);\r\n}\r\n","// Stacked Icons\r\n// -------------------------\r\n\r\n.@{fa-css-prefix}-stack {\r\n  position: relative;\r\n  display: inline-block;\r\n  width: 2em;\r\n  height: 2em;\r\n  line-height: 2em;\r\n  vertical-align: middle;\r\n}\r\n.@{fa-css-prefix}-stack-1x, .@{fa-css-prefix}-stack-2x {\r\n  position: absolute;\r\n  left: 0;\r\n  width: 100%;\r\n  text-align: center;\r\n}\r\n.@{fa-css-prefix}-stack-1x { line-height: inherit; }\r\n.@{fa-css-prefix}-stack-2x { font-size: 2em; }\r\n.@{fa-css-prefix}-inverse { color: @fa-inverse; }\r\n","/* Font Awesome uses the Unicode Private Use Area (PUA) to ensure screen\r\n   readers do not read off random characters that represent icons */\r\n\r\n.@{fa-css-prefix}-glass:before { content: @fa-var-glass; }\r\n.@{fa-css-prefix}-music:before { content: @fa-var-music; }\r\n.@{fa-css-prefix}-search:before { content: @fa-var-search; }\r\n.@{fa-css-prefix}-envelope-o:before { content: @fa-var-envelope-o; }\r\n.@{fa-css-prefix}-heart:before { content: @fa-var-heart; }\r\n.@{fa-css-prefix}-star:before { content: @fa-var-star; }\r\n.@{fa-css-prefix}-star-o:before { content: @fa-var-star-o; }\r\n.@{fa-css-prefix}-user:before { content: @fa-var-user; }\r\n.@{fa-css-prefix}-film:before { content: @fa-var-film; }\r\n.@{fa-css-prefix}-th-large:before { content: @fa-var-th-large; }\r\n.@{fa-css-prefix}-th:before { content: @fa-var-th; }\r\n.@{fa-css-prefix}-th-list:before { content: @fa-var-th-list; }\r\n.@{fa-css-prefix}-check:before { content: @fa-var-check; }\r\n.@{fa-css-prefix}-remove:before,\r\n.@{fa-css-prefix}-close:before,\r\n.@{fa-css-prefix}-times:before { content: @fa-var-times; }\r\n.@{fa-css-prefix}-search-plus:before { content: @fa-var-search-plus; }\r\n.@{fa-css-prefix}-search-minus:before { content: @fa-var-search-minus; }\r\n.@{fa-css-prefix}-power-off:before { content: @fa-var-power-off; }\r\n.@{fa-css-prefix}-signal:before { content: @fa-var-signal; }\r\n.@{fa-css-prefix}-gear:before,\r\n.@{fa-css-prefix}-cog:before { content: @fa-var-cog; }\r\n.@{fa-css-prefix}-trash-o:before { content: @fa-var-trash-o; }\r\n.@{fa-css-prefix}-home:before { content: @fa-var-home; }\r\n.@{fa-css-prefix}-file-o:before { content: @fa-var-file-o; }\r\n.@{fa-css-prefix}-clock-o:before { content: @fa-var-clock-o; }\r\n.@{fa-css-prefix}-road:before { content: @fa-var-road; }\r\n.@{fa-css-prefix}-download:before { content: @fa-var-download; }\r\n.@{fa-css-prefix}-arrow-circle-o-down:before { content: @fa-var-arrow-circle-o-down; }\r\n.@{fa-css-prefix}-arrow-circle-o-up:before { content: @fa-var-arrow-circle-o-up; }\r\n.@{fa-css-prefix}-inbox:before { content: @fa-var-inbox; }\r\n.@{fa-css-prefix}-play-circle-o:before { content: @fa-var-play-circle-o; }\r\n.@{fa-css-prefix}-rotate-right:before,\r\n.@{fa-css-prefix}-repeat:before { content: @fa-var-repeat; }\r\n.@{fa-css-prefix}-refresh:before { content: @fa-var-refresh; }\r\n.@{fa-css-prefix}-list-alt:before { content: @fa-var-list-alt; }\r\n.@{fa-css-prefix}-lock:before { content: @fa-var-lock; }\r\n.@{fa-css-prefix}-flag:before { content: @fa-var-flag; }\r\n.@{fa-css-prefix}-headphones:before { content: @fa-var-headphones; }\r\n.@{fa-css-prefix}-volume-off:before { content: @fa-var-volume-off; }\r\n.@{fa-css-prefix}-volume-down:before { content: @fa-var-volume-down; }\r\n.@{fa-css-prefix}-volume-up:before { content: @fa-var-volume-up; }\r\n.@{fa-css-prefix}-qrcode:before { content: @fa-var-qrcode; }\r\n.@{fa-css-prefix}-barcode:before { content: @fa-var-barcode; }\r\n.@{fa-css-prefix}-tag:before { content: @fa-var-tag; }\r\n.@{fa-css-prefix}-tags:before { content: @fa-var-tags; }\r\n.@{fa-css-prefix}-book:before { content: @fa-var-book; }\r\n.@{fa-css-prefix}-bookmark:before { content: @fa-var-bookmark; }\r\n.@{fa-css-prefix}-print:before { content: @fa-var-print; }\r\n.@{fa-css-prefix}-camera:before { content: @fa-var-camera; }\r\n.@{fa-css-prefix}-font:before { content: @fa-var-font; }\r\n.@{fa-css-prefix}-bold:before { content: @fa-var-bold; }\r\n.@{fa-css-prefix}-italic:before { content: @fa-var-italic; }\r\n.@{fa-css-prefix}-text-height:before { content: @fa-var-text-height; }\r\n.@{fa-css-prefix}-text-width:before { content: @fa-var-text-width; }\r\n.@{fa-css-prefix}-align-left:before { content: @fa-var-align-left; }\r\n.@{fa-css-prefix}-align-center:before { content: @fa-var-align-center; }\r\n.@{fa-css-prefix}-align-right:before { content: @fa-var-align-right; }\r\n.@{fa-css-prefix}-align-justify:before { content: @fa-var-align-justify; }\r\n.@{fa-css-prefix}-list:before { content: @fa-var-list; }\r\n.@{fa-css-prefix}-dedent:before,\r\n.@{fa-css-prefix}-outdent:before { content: @fa-var-outdent; }\r\n.@{fa-css-prefix}-indent:before { content: @fa-var-indent; }\r\n.@{fa-css-prefix}-video-camera:before { content: @fa-var-video-camera; }\r\n.@{fa-css-prefix}-photo:before,\r\n.@{fa-css-prefix}-image:before,\r\n.@{fa-css-prefix}-picture-o:before { content: @fa-var-picture-o; }\r\n.@{fa-css-prefix}-pencil:before { content: @fa-var-pencil; }\r\n.@{fa-css-prefix}-map-marker:before { content: @fa-var-map-marker; }\r\n.@{fa-css-prefix}-adjust:before { content: @fa-var-adjust; }\r\n.@{fa-css-prefix}-tint:before { content: @fa-var-tint; }\r\n.@{fa-css-prefix}-edit:before,\r\n.@{fa-css-prefix}-pencil-square-o:before { content: @fa-var-pencil-square-o; }\r\n.@{fa-css-prefix}-share-square-o:before { content: @fa-var-share-square-o; }\r\n.@{fa-css-prefix}-check-square-o:before { content: @fa-var-check-square-o; }\r\n.@{fa-css-prefix}-arrows:before { content: @fa-var-arrows; }\r\n.@{fa-css-prefix}-step-backward:before { content: @fa-var-step-backward; }\r\n.@{fa-css-prefix}-fast-backward:before { content: @fa-var-fast-backward; }\r\n.@{fa-css-prefix}-backward:before { content: @fa-var-backward; }\r\n.@{fa-css-prefix}-play:before { content: @fa-var-play; }\r\n.@{fa-css-prefix}-pause:before { content: @fa-var-pause; }\r\n.@{fa-css-prefix}-stop:before { content: @fa-var-stop; }\r\n.@{fa-css-prefix}-forward:before { content: @fa-var-forward; }\r\n.@{fa-css-prefix}-fast-forward:before { content: @fa-var-fast-forward; }\r\n.@{fa-css-prefix}-step-forward:before { content: @fa-var-step-forward; }\r\n.@{fa-css-prefix}-eject:before { content: @fa-var-eject; }\r\n.@{fa-css-prefix}-chevron-left:before { content: @fa-var-chevron-left; }\r\n.@{fa-css-prefix}-chevron-right:before { content: @fa-var-chevron-right; }\r\n.@{fa-css-prefix}-plus-circle:before { content: @fa-var-plus-circle; }\r\n.@{fa-css-prefix}-minus-circle:before { content: @fa-var-minus-circle; }\r\n.@{fa-css-prefix}-times-circle:before { content: @fa-var-times-circle; }\r\n.@{fa-css-prefix}-check-circle:before { content: @fa-var-check-circle; }\r\n.@{fa-css-prefix}-question-circle:before { content: @fa-var-question-circle; }\r\n.@{fa-css-prefix}-info-circle:before { content: @fa-var-info-circle; }\r\n.@{fa-css-prefix}-crosshairs:before { content: @fa-var-crosshairs; }\r\n.@{fa-css-prefix}-times-circle-o:before { content: @fa-var-times-circle-o; }\r\n.@{fa-css-prefix}-check-circle-o:before { content: @fa-var-check-circle-o; }\r\n.@{fa-css-prefix}-ban:before { content: @fa-var-ban; }\r\n.@{fa-css-prefix}-arrow-left:before { content: @fa-var-arrow-left; }\r\n.@{fa-css-prefix}-arrow-right:before { content: @fa-var-arrow-right; }\r\n.@{fa-css-prefix}-arrow-up:before { content: @fa-var-arrow-up; }\r\n.@{fa-css-prefix}-arrow-down:before { content: @fa-var-arrow-down; }\r\n.@{fa-css-prefix}-mail-forward:before,\r\n.@{fa-css-prefix}-share:before { content: @fa-var-share; }\r\n.@{fa-css-prefix}-expand:before { content: @fa-var-expand; }\r\n.@{fa-css-prefix}-compress:before { content: @fa-var-compress; }\r\n.@{fa-css-prefix}-plus:before { content: @fa-var-plus; }\r\n.@{fa-css-prefix}-minus:before { content: @fa-var-minus; }\r\n.@{fa-css-prefix}-asterisk:before { content: @fa-var-asterisk; }\r\n.@{fa-css-prefix}-exclamation-circle:before { content: @fa-var-exclamation-circle; }\r\n.@{fa-css-prefix}-gift:before { content: @fa-var-gift; }\r\n.@{fa-css-prefix}-leaf:before { content: @fa-var-leaf; }\r\n.@{fa-css-prefix}-fire:before { content: @fa-var-fire; }\r\n.@{fa-css-prefix}-eye:before { content: @fa-var-eye; }\r\n.@{fa-css-prefix}-eye-slash:before { content: @fa-var-eye-slash; }\r\n.@{fa-css-prefix}-warning:before,\r\n.@{fa-css-prefix}-exclamation-triangle:before { content: @fa-var-exclamation-triangle; }\r\n.@{fa-css-prefix}-plane:before { content: @fa-var-plane; }\r\n.@{fa-css-prefix}-calendar:before { content: @fa-var-calendar; }\r\n.@{fa-css-prefix}-random:before { content: @fa-var-random; }\r\n.@{fa-css-prefix}-comment:before { content: @fa-var-comment; }\r\n.@{fa-css-prefix}-magnet:before { content: @fa-var-magnet; }\r\n.@{fa-css-prefix}-chevron-up:before { content: @fa-var-chevron-up; }\r\n.@{fa-css-prefix}-chevron-down:before { content: @fa-var-chevron-down; }\r\n.@{fa-css-prefix}-retweet:before { content: @fa-var-retweet; }\r\n.@{fa-css-prefix}-shopping-cart:before { content: @fa-var-shopping-cart; }\r\n.@{fa-css-prefix}-folder:before { content: @fa-var-folder; }\r\n.@{fa-css-prefix}-folder-open:before { content: @fa-var-folder-open; }\r\n.@{fa-css-prefix}-arrows-v:before { content: @fa-var-arrows-v; }\r\n.@{fa-css-prefix}-arrows-h:before { content: @fa-var-arrows-h; }\r\n.@{fa-css-prefix}-bar-chart-o:before,\r\n.@{fa-css-prefix}-bar-chart:before { content: @fa-var-bar-chart; }\r\n.@{fa-css-prefix}-twitter-square:before { content: @fa-var-twitter-square; }\r\n.@{fa-css-prefix}-facebook-square:before { content: @fa-var-facebook-square; }\r\n.@{fa-css-prefix}-camera-retro:before { content: @fa-var-camera-retro; }\r\n.@{fa-css-prefix}-key:before { content: @fa-var-key; }\r\n.@{fa-css-prefix}-gears:before,\r\n.@{fa-css-prefix}-cogs:before { content: @fa-var-cogs; }\r\n.@{fa-css-prefix}-comments:before { content: @fa-var-comments; }\r\n.@{fa-css-prefix}-thumbs-o-up:before { content: @fa-var-thumbs-o-up; }\r\n.@{fa-css-prefix}-thumbs-o-down:before { content: @fa-var-thumbs-o-down; }\r\n.@{fa-css-prefix}-star-half:before { content: @fa-var-star-half; }\r\n.@{fa-css-prefix}-heart-o:before { content: @fa-var-heart-o; }\r\n.@{fa-css-prefix}-sign-out:before { content: @fa-var-sign-out; }\r\n.@{fa-css-prefix}-linkedin-square:before { content: @fa-var-linkedin-square; }\r\n.@{fa-css-prefix}-thumb-tack:before { content: @fa-var-thumb-tack; }\r\n.@{fa-css-prefix}-external-link:before { content: @fa-var-external-link; }\r\n.@{fa-css-prefix}-sign-in:before { content: @fa-var-sign-in; }\r\n.@{fa-css-prefix}-trophy:before { content: @fa-var-trophy; }\r\n.@{fa-css-prefix}-github-square:before { content: @fa-var-github-square; }\r\n.@{fa-css-prefix}-upload:before { content: @fa-var-upload; }\r\n.@{fa-css-prefix}-lemon-o:before { content: @fa-var-lemon-o; }\r\n.@{fa-css-prefix}-phone:before { content: @fa-var-phone; }\r\n.@{fa-css-prefix}-square-o:before { content: @fa-var-square-o; }\r\n.@{fa-css-prefix}-bookmark-o:before { content: @fa-var-bookmark-o; }\r\n.@{fa-css-prefix}-phone-square:before { content: @fa-var-phone-square; }\r\n.@{fa-css-prefix}-twitter:before { content: @fa-var-twitter; }\r\n.@{fa-css-prefix}-facebook-f:before,\r\n.@{fa-css-prefix}-facebook:before { content: @fa-var-facebook; }\r\n.@{fa-css-prefix}-github:before { content: @fa-var-github; }\r\n.@{fa-css-prefix}-unlock:before { content: @fa-var-unlock; }\r\n.@{fa-css-prefix}-credit-card:before { content: @fa-var-credit-card; }\r\n.@{fa-css-prefix}-rss:before { content: @fa-var-rss; }\r\n.@{fa-css-prefix}-hdd-o:before { content: @fa-var-hdd-o; }\r\n.@{fa-css-prefix}-bullhorn:before { content: @fa-var-bullhorn; }\r\n.@{fa-css-prefix}-bell:before { content: @fa-var-bell; }\r\n.@{fa-css-prefix}-certificate:before { content: @fa-var-certificate; }\r\n.@{fa-css-prefix}-hand-o-right:before { content: @fa-var-hand-o-right; }\r\n.@{fa-css-prefix}-hand-o-left:before { content: @fa-var-hand-o-left; }\r\n.@{fa-css-prefix}-hand-o-up:before { content: @fa-var-hand-o-up; }\r\n.@{fa-css-prefix}-hand-o-down:before { content: @fa-var-hand-o-down; }\r\n.@{fa-css-prefix}-arrow-circle-left:before { content: @fa-var-arrow-circle-left; }\r\n.@{fa-css-prefix}-arrow-circle-right:before { content: @fa-var-arrow-circle-right; }\r\n.@{fa-css-prefix}-arrow-circle-up:before { content: @fa-var-arrow-circle-up; }\r\n.@{fa-css-prefix}-arrow-circle-down:before { content: @fa-var-arrow-circle-down; }\r\n.@{fa-css-prefix}-globe:before { content: @fa-var-globe; }\r\n.@{fa-css-prefix}-wrench:before { content: @fa-var-wrench; }\r\n.@{fa-css-prefix}-tasks:before { content: @fa-var-tasks; }\r\n.@{fa-css-prefix}-filter:before { content: @fa-var-filter; }\r\n.@{fa-css-prefix}-briefcase:before { content: @fa-var-briefcase; }\r\n.@{fa-css-prefix}-arrows-alt:before { content: @fa-var-arrows-alt; }\r\n.@{fa-css-prefix}-group:before,\r\n.@{fa-css-prefix}-users:before { content: @fa-var-users; }\r\n.@{fa-css-prefix}-chain:before,\r\n.@{fa-css-prefix}-link:before { content: @fa-var-link; }\r\n.@{fa-css-prefix}-cloud:before { content: @fa-var-cloud; }\r\n.@{fa-css-prefix}-flask:before { content: @fa-var-flask; }\r\n.@{fa-css-prefix}-cut:before,\r\n.@{fa-css-prefix}-scissors:before { content: @fa-var-scissors; }\r\n.@{fa-css-prefix}-copy:before,\r\n.@{fa-css-prefix}-files-o:before { content: @fa-var-files-o; }\r\n.@{fa-css-prefix}-paperclip:before { content: @fa-var-paperclip; }\r\n.@{fa-css-prefix}-save:before,\r\n.@{fa-css-prefix}-floppy-o:before { content: @fa-var-floppy-o; }\r\n.@{fa-css-prefix}-square:before { content: @fa-var-square; }\r\n.@{fa-css-prefix}-navicon:before,\r\n.@{fa-css-prefix}-reorder:before,\r\n.@{fa-css-prefix}-bars:before { content: @fa-var-bars; }\r\n.@{fa-css-prefix}-list-ul:before { content: @fa-var-list-ul; }\r\n.@{fa-css-prefix}-list-ol:before { content: @fa-var-list-ol; }\r\n.@{fa-css-prefix}-strikethrough:before { content: @fa-var-strikethrough; }\r\n.@{fa-css-prefix}-underline:before { content: @fa-var-underline; }\r\n.@{fa-css-prefix}-table:before { content: @fa-var-table; }\r\n.@{fa-css-prefix}-magic:before { content: @fa-var-magic; }\r\n.@{fa-css-prefix}-truck:before { content: @fa-var-truck; }\r\n.@{fa-css-prefix}-pinterest:before { content: @fa-var-pinterest; }\r\n.@{fa-css-prefix}-pinterest-square:before { content: @fa-var-pinterest-square; }\r\n.@{fa-css-prefix}-google-plus-square:before { content: @fa-var-google-plus-square; }\r\n.@{fa-css-prefix}-google-plus:before { content: @fa-var-google-plus; }\r\n.@{fa-css-prefix}-money:before { content: @fa-var-money; }\r\n.@{fa-css-prefix}-caret-down:before { content: @fa-var-caret-down; }\r\n.@{fa-css-prefix}-caret-up:before { content: @fa-var-caret-up; }\r\n.@{fa-css-prefix}-caret-left:before { content: @fa-var-caret-left; }\r\n.@{fa-css-prefix}-caret-right:before { content: @fa-var-caret-right; }\r\n.@{fa-css-prefix}-columns:before { content: @fa-var-columns; }\r\n.@{fa-css-prefix}-unsorted:before,\r\n.@{fa-css-prefix}-sort:before { content: @fa-var-sort; }\r\n.@{fa-css-prefix}-sort-down:before,\r\n.@{fa-css-prefix}-sort-desc:before { content: @fa-var-sort-desc; }\r\n.@{fa-css-prefix}-sort-up:before,\r\n.@{fa-css-prefix}-sort-asc:before { content: @fa-var-sort-asc; }\r\n.@{fa-css-prefix}-envelope:before { content: @fa-var-envelope; }\r\n.@{fa-css-prefix}-linkedin:before { content: @fa-var-linkedin; }\r\n.@{fa-css-prefix}-rotate-left:before,\r\n.@{fa-css-prefix}-undo:before { content: @fa-var-undo; }\r\n.@{fa-css-prefix}-legal:before,\r\n.@{fa-css-prefix}-gavel:before { content: @fa-var-gavel; }\r\n.@{fa-css-prefix}-dashboard:before,\r\n.@{fa-css-prefix}-tachometer:before { content: @fa-var-tachometer; }\r\n.@{fa-css-prefix}-comment-o:before { content: @fa-var-comment-o; }\r\n.@{fa-css-prefix}-comments-o:before { content: @fa-var-comments-o; }\r\n.@{fa-css-prefix}-flash:before,\r\n.@{fa-css-prefix}-bolt:before { content: @fa-var-bolt; }\r\n.@{fa-css-prefix}-sitemap:before { content: @fa-var-sitemap; }\r\n.@{fa-css-prefix}-umbrella:before { content: @fa-var-umbrella; }\r\n.@{fa-css-prefix}-paste:before,\r\n.@{fa-css-prefix}-clipboard:before { content: @fa-var-clipboard; }\r\n.@{fa-css-prefix}-lightbulb-o:before { content: @fa-var-lightbulb-o; }\r\n.@{fa-css-prefix}-exchange:before { content: @fa-var-exchange; }\r\n.@{fa-css-prefix}-cloud-download:before { content: @fa-var-cloud-download; }\r\n.@{fa-css-prefix}-cloud-upload:before { content: @fa-var-cloud-upload; }\r\n.@{fa-css-prefix}-user-md:before { content: @fa-var-user-md; }\r\n.@{fa-css-prefix}-stethoscope:before { content: @fa-var-stethoscope; }\r\n.@{fa-css-prefix}-suitcase:before { content: @fa-var-suitcase; }\r\n.@{fa-css-prefix}-bell-o:before { content: @fa-var-bell-o; }\r\n.@{fa-css-prefix}-coffee:before { content: @fa-var-coffee; }\r\n.@{fa-css-prefix}-cutlery:before { content: @fa-var-cutlery; }\r\n.@{fa-css-prefix}-file-text-o:before { content: @fa-var-file-text-o; }\r\n.@{fa-css-prefix}-building-o:before { content: @fa-var-building-o; }\r\n.@{fa-css-prefix}-hospital-o:before { content: @fa-var-hospital-o; }\r\n.@{fa-css-prefix}-ambulance:before { content: @fa-var-ambulance; }\r\n.@{fa-css-prefix}-medkit:before { content: @fa-var-medkit; }\r\n.@{fa-css-prefix}-fighter-jet:before { content: @fa-var-fighter-jet; }\r\n.@{fa-css-prefix}-beer:before { content: @fa-var-beer; }\r\n.@{fa-css-prefix}-h-square:before { content: @fa-var-h-square; }\r\n.@{fa-css-prefix}-plus-square:before { content: @fa-var-plus-square; }\r\n.@{fa-css-prefix}-angle-double-left:before { content: @fa-var-angle-double-left; }\r\n.@{fa-css-prefix}-angle-double-right:before { content: @fa-var-angle-double-right; }\r\n.@{fa-css-prefix}-angle-double-up:before { content: @fa-var-angle-double-up; }\r\n.@{fa-css-prefix}-angle-double-down:before { content: @fa-var-angle-double-down; }\r\n.@{fa-css-prefix}-angle-left:before { content: @fa-var-angle-left; }\r\n.@{fa-css-prefix}-angle-right:before { content: @fa-var-angle-right; }\r\n.@{fa-css-prefix}-angle-up:before { content: @fa-var-angle-up; }\r\n.@{fa-css-prefix}-angle-down:before { content: @fa-var-angle-down; }\r\n.@{fa-css-prefix}-desktop:before { content: @fa-var-desktop; }\r\n.@{fa-css-prefix}-laptop:before { content: @fa-var-laptop; }\r\n.@{fa-css-prefix}-tablet:before { content: @fa-var-tablet; }\r\n.@{fa-css-prefix}-mobile-phone:before,\r\n.@{fa-css-prefix}-mobile:before { content: @fa-var-mobile; }\r\n.@{fa-css-prefix}-circle-o:before { content: @fa-var-circle-o; }\r\n.@{fa-css-prefix}-quote-left:before { content: @fa-var-quote-left; }\r\n.@{fa-css-prefix}-quote-right:before { content: @fa-var-quote-right; }\r\n.@{fa-css-prefix}-spinner:before { content: @fa-var-spinner; }\r\n.@{fa-css-prefix}-circle:before { content: @fa-var-circle; }\r\n.@{fa-css-prefix}-mail-reply:before,\r\n.@{fa-css-prefix}-reply:before { content: @fa-var-reply; }\r\n.@{fa-css-prefix}-github-alt:before { content: @fa-var-github-alt; }\r\n.@{fa-css-prefix}-folder-o:before { content: @fa-var-folder-o; }\r\n.@{fa-css-prefix}-folder-open-o:before { content: @fa-var-folder-open-o; }\r\n.@{fa-css-prefix}-smile-o:before { content: @fa-var-smile-o; }\r\n.@{fa-css-prefix}-frown-o:before { content: @fa-var-frown-o; }\r\n.@{fa-css-prefix}-meh-o:before { content: @fa-var-meh-o; }\r\n.@{fa-css-prefix}-gamepad:before { content: @fa-var-gamepad; }\r\n.@{fa-css-prefix}-keyboard-o:before { content: @fa-var-keyboard-o; }\r\n.@{fa-css-prefix}-flag-o:before { content: @fa-var-flag-o; }\r\n.@{fa-css-prefix}-flag-checkered:before { content: @fa-var-flag-checkered; }\r\n.@{fa-css-prefix}-terminal:before { content: @fa-var-terminal; }\r\n.@{fa-css-prefix}-code:before { content: @fa-var-code; }\r\n.@{fa-css-prefix}-mail-reply-all:before,\r\n.@{fa-css-prefix}-reply-all:before { content: @fa-var-reply-all; }\r\n.@{fa-css-prefix}-star-half-empty:before,\r\n.@{fa-css-prefix}-star-half-full:before,\r\n.@{fa-css-prefix}-star-half-o:before { content: @fa-var-star-half-o; }\r\n.@{fa-css-prefix}-location-arrow:before { content: @fa-var-location-arrow; }\r\n.@{fa-css-prefix}-crop:before { content: @fa-var-crop; }\r\n.@{fa-css-prefix}-code-fork:before { content: @fa-var-code-fork; }\r\n.@{fa-css-prefix}-unlink:before,\r\n.@{fa-css-prefix}-chain-broken:before { content: @fa-var-chain-broken; }\r\n.@{fa-css-prefix}-question:before { content: @fa-var-question; }\r\n.@{fa-css-prefix}-info:before { content: @fa-var-info; }\r\n.@{fa-css-prefix}-exclamation:before { content: @fa-var-exclamation; }\r\n.@{fa-css-prefix}-superscript:before { content: @fa-var-superscript; }\r\n.@{fa-css-prefix}-subscript:before { content: @fa-var-subscript; }\r\n.@{fa-css-prefix}-eraser:before { content: @fa-var-eraser; }\r\n.@{fa-css-prefix}-puzzle-piece:before { content: @fa-var-puzzle-piece; }\r\n.@{fa-css-prefix}-microphone:before { content: @fa-var-microphone; }\r\n.@{fa-css-prefix}-microphone-slash:before { content: @fa-var-microphone-slash; }\r\n.@{fa-css-prefix}-shield:before { content: @fa-var-shield; }\r\n.@{fa-css-prefix}-calendar-o:before { content: @fa-var-calendar-o; }\r\n.@{fa-css-prefix}-fire-extinguisher:before { content: @fa-var-fire-extinguisher; }\r\n.@{fa-css-prefix}-rocket:before { content: @fa-var-rocket; }\r\n.@{fa-css-prefix}-maxcdn:before { content: @fa-var-maxcdn; }\r\n.@{fa-css-prefix}-chevron-circle-left:before { content: @fa-var-chevron-circle-left; }\r\n.@{fa-css-prefix}-chevron-circle-right:before { content: @fa-var-chevron-circle-right; }\r\n.@{fa-css-prefix}-chevron-circle-up:before { content: @fa-var-chevron-circle-up; }\r\n.@{fa-css-prefix}-chevron-circle-down:before { content: @fa-var-chevron-circle-down; }\r\n.@{fa-css-prefix}-html5:before { content: @fa-var-html5; }\r\n.@{fa-css-prefix}-css3:before { content: @fa-var-css3; }\r\n.@{fa-css-prefix}-anchor:before { content: @fa-var-anchor; }\r\n.@{fa-css-prefix}-unlock-alt:before { content: @fa-var-unlock-alt; }\r\n.@{fa-css-prefix}-bullseye:before { content: @fa-var-bullseye; }\r\n.@{fa-css-prefix}-ellipsis-h:before { content: @fa-var-ellipsis-h; }\r\n.@{fa-css-prefix}-ellipsis-v:before { content: @fa-var-ellipsis-v; }\r\n.@{fa-css-prefix}-rss-square:before { content: @fa-var-rss-square; }\r\n.@{fa-css-prefix}-play-circle:before { content: @fa-var-play-circle; }\r\n.@{fa-css-prefix}-ticket:before { content: @fa-var-ticket; }\r\n.@{fa-css-prefix}-minus-square:before { content: @fa-var-minus-square; }\r\n.@{fa-css-prefix}-minus-square-o:before { content: @fa-var-minus-square-o; }\r\n.@{fa-css-prefix}-level-up:before { content: @fa-var-level-up; }\r\n.@{fa-css-prefix}-level-down:before { content: @fa-var-level-down; }\r\n.@{fa-css-prefix}-check-square:before { content: @fa-var-check-square; }\r\n.@{fa-css-prefix}-pencil-square:before { content: @fa-var-pencil-square; }\r\n.@{fa-css-prefix}-external-link-square:before { content: @fa-var-external-link-square; }\r\n.@{fa-css-prefix}-share-square:before { content: @fa-var-share-square; }\r\n.@{fa-css-prefix}-compass:before { content: @fa-var-compass; }\r\n.@{fa-css-prefix}-toggle-down:before,\r\n.@{fa-css-prefix}-caret-square-o-down:before { content: @fa-var-caret-square-o-down; }\r\n.@{fa-css-prefix}-toggle-up:before,\r\n.@{fa-css-prefix}-caret-square-o-up:before { content: @fa-var-caret-square-o-up; }\r\n.@{fa-css-prefix}-toggle-right:before,\r\n.@{fa-css-prefix}-caret-square-o-right:before { content: @fa-var-caret-square-o-right; }\r\n.@{fa-css-prefix}-euro:before,\r\n.@{fa-css-prefix}-eur:before { content: @fa-var-eur; }\r\n.@{fa-css-prefix}-gbp:before { content: @fa-var-gbp; }\r\n.@{fa-css-prefix}-dollar:before,\r\n.@{fa-css-prefix}-usd:before { content: @fa-var-usd; }\r\n.@{fa-css-prefix}-rupee:before,\r\n.@{fa-css-prefix}-inr:before { content: @fa-var-inr; }\r\n.@{fa-css-prefix}-cny:before,\r\n.@{fa-css-prefix}-rmb:before,\r\n.@{fa-css-prefix}-yen:before,\r\n.@{fa-css-prefix}-jpy:before { content: @fa-var-jpy; }\r\n.@{fa-css-prefix}-ruble:before,\r\n.@{fa-css-prefix}-rouble:before,\r\n.@{fa-css-prefix}-rub:before { content: @fa-var-rub; }\r\n.@{fa-css-prefix}-won:before,\r\n.@{fa-css-prefix}-krw:before { content: @fa-var-krw; }\r\n.@{fa-css-prefix}-bitcoin:before,\r\n.@{fa-css-prefix}-btc:before { content: @fa-var-btc; }\r\n.@{fa-css-prefix}-file:before { content: @fa-var-file; }\r\n.@{fa-css-prefix}-file-text:before { content: @fa-var-file-text; }\r\n.@{fa-css-prefix}-sort-alpha-asc:before { content: @fa-var-sort-alpha-asc; }\r\n.@{fa-css-prefix}-sort-alpha-desc:before { content: @fa-var-sort-alpha-desc; }\r\n.@{fa-css-prefix}-sort-amount-asc:before { content: @fa-var-sort-amount-asc; }\r\n.@{fa-css-prefix}-sort-amount-desc:before { content: @fa-var-sort-amount-desc; }\r\n.@{fa-css-prefix}-sort-numeric-asc:before { content: @fa-var-sort-numeric-asc; }\r\n.@{fa-css-prefix}-sort-numeric-desc:before { content: @fa-var-sort-numeric-desc; }\r\n.@{fa-css-prefix}-thumbs-up:before { content: @fa-var-thumbs-up; }\r\n.@{fa-css-prefix}-thumbs-down:before { content: @fa-var-thumbs-down; }\r\n.@{fa-css-prefix}-youtube-square:before { content: @fa-var-youtube-square; }\r\n.@{fa-css-prefix}-youtube:before { content: @fa-var-youtube; }\r\n.@{fa-css-prefix}-xing:before { content: @fa-var-xing; }\r\n.@{fa-css-prefix}-xing-square:before { content: @fa-var-xing-square; }\r\n.@{fa-css-prefix}-youtube-play:before { content: @fa-var-youtube-play; }\r\n.@{fa-css-prefix}-dropbox:before { content: @fa-var-dropbox; }\r\n.@{fa-css-prefix}-stack-overflow:before { content: @fa-var-stack-overflow; }\r\n.@{fa-css-prefix}-instagram:before { content: @fa-var-instagram; }\r\n.@{fa-css-prefix}-flickr:before { content: @fa-var-flickr; }\r\n.@{fa-css-prefix}-adn:before { content: @fa-var-adn; }\r\n.@{fa-css-prefix}-bitbucket:before { content: @fa-var-bitbucket; }\r\n.@{fa-css-prefix}-bitbucket-square:before { content: @fa-var-bitbucket-square; }\r\n.@{fa-css-prefix}-tumblr:before { content: @fa-var-tumblr; }\r\n.@{fa-css-prefix}-tumblr-square:before { content: @fa-var-tumblr-square; }\r\n.@{fa-css-prefix}-long-arrow-down:before { content: @fa-var-long-arrow-down; }\r\n.@{fa-css-prefix}-long-arrow-up:before { content: @fa-var-long-arrow-up; }\r\n.@{fa-css-prefix}-long-arrow-left:before { content: @fa-var-long-arrow-left; }\r\n.@{fa-css-prefix}-long-arrow-right:before { content: @fa-var-long-arrow-right; }\r\n.@{fa-css-prefix}-apple:before { content: @fa-var-apple; }\r\n.@{fa-css-prefix}-windows:before { content: @fa-var-windows; }\r\n.@{fa-css-prefix}-android:before { content: @fa-var-android; }\r\n.@{fa-css-prefix}-linux:before { content: @fa-var-linux; }\r\n.@{fa-css-prefix}-dribbble:before { content: @fa-var-dribbble; }\r\n.@{fa-css-prefix}-skype:before { content: @fa-var-skype; }\r\n.@{fa-css-prefix}-foursquare:before { content: @fa-var-foursquare; }\r\n.@{fa-css-prefix}-trello:before { content: @fa-var-trello; }\r\n.@{fa-css-prefix}-female:before { content: @fa-var-female; }\r\n.@{fa-css-prefix}-male:before { content: @fa-var-male; }\r\n.@{fa-css-prefix}-gittip:before,\r\n.@{fa-css-prefix}-gratipay:before { content: @fa-var-gratipay; }\r\n.@{fa-css-prefix}-sun-o:before { content: @fa-var-sun-o; }\r\n.@{fa-css-prefix}-moon-o:before { content: @fa-var-moon-o; }\r\n.@{fa-css-prefix}-archive:before { content: @fa-var-archive; }\r\n.@{fa-css-prefix}-bug:before { content: @fa-var-bug; }\r\n.@{fa-css-prefix}-vk:before { content: @fa-var-vk; }\r\n.@{fa-css-prefix}-weibo:before { content: @fa-var-weibo; }\r\n.@{fa-css-prefix}-renren:before { content: @fa-var-renren; }\r\n.@{fa-css-prefix}-pagelines:before { content: @fa-var-pagelines; }\r\n.@{fa-css-prefix}-stack-exchange:before { content: @fa-var-stack-exchange; }\r\n.@{fa-css-prefix}-arrow-circle-o-right:before { content: @fa-var-arrow-circle-o-right; }\r\n.@{fa-css-prefix}-arrow-circle-o-left:before { content: @fa-var-arrow-circle-o-left; }\r\n.@{fa-css-prefix}-toggle-left:before,\r\n.@{fa-css-prefix}-caret-square-o-left:before { content: @fa-var-caret-square-o-left; }\r\n.@{fa-css-prefix}-dot-circle-o:before { content: @fa-var-dot-circle-o; }\r\n.@{fa-css-prefix}-wheelchair:before { content: @fa-var-wheelchair; }\r\n.@{fa-css-prefix}-vimeo-square:before { content: @fa-var-vimeo-square; }\r\n.@{fa-css-prefix}-turkish-lira:before,\r\n.@{fa-css-prefix}-try:before { content: @fa-var-try; }\r\n.@{fa-css-prefix}-plus-square-o:before { content: @fa-var-plus-square-o; }\r\n.@{fa-css-prefix}-space-shuttle:before { content: @fa-var-space-shuttle; }\r\n.@{fa-css-prefix}-slack:before { content: @fa-var-slack; }\r\n.@{fa-css-prefix}-envelope-square:before { content: @fa-var-envelope-square; }\r\n.@{fa-css-prefix}-wordpress:before { content: @fa-var-wordpress; }\r\n.@{fa-css-prefix}-openid:before { content: @fa-var-openid; }\r\n.@{fa-css-prefix}-institution:before,\r\n.@{fa-css-prefix}-bank:before,\r\n.@{fa-css-prefix}-university:before { content: @fa-var-university; }\r\n.@{fa-css-prefix}-mortar-board:before,\r\n.@{fa-css-prefix}-graduation-cap:before { content: @fa-var-graduation-cap; }\r\n.@{fa-css-prefix}-yahoo:before { content: @fa-var-yahoo; }\r\n.@{fa-css-prefix}-google:before { content: @fa-var-google; }\r\n.@{fa-css-prefix}-reddit:before { content: @fa-var-reddit; }\r\n.@{fa-css-prefix}-reddit-square:before { content: @fa-var-reddit-square; }\r\n.@{fa-css-prefix}-stumbleupon-circle:before { content: @fa-var-stumbleupon-circle; }\r\n.@{fa-css-prefix}-stumbleupon:before { content: @fa-var-stumbleupon; }\r\n.@{fa-css-prefix}-delicious:before { content: @fa-var-delicious; }\r\n.@{fa-css-prefix}-digg:before { content: @fa-var-digg; }\r\n.@{fa-css-prefix}-pied-piper:before { content: @fa-var-pied-piper; }\r\n.@{fa-css-prefix}-pied-piper-alt:before { content: @fa-var-pied-piper-alt; }\r\n.@{fa-css-prefix}-drupal:before { content: @fa-var-drupal; }\r\n.@{fa-css-prefix}-joomla:before { content: @fa-var-joomla; }\r\n.@{fa-css-prefix}-language:before { content: @fa-var-language; }\r\n.@{fa-css-prefix}-fax:before { content: @fa-var-fax; }\r\n.@{fa-css-prefix}-building:before { content: @fa-var-building; }\r\n.@{fa-css-prefix}-child:before { content: @fa-var-child; }\r\n.@{fa-css-prefix}-paw:before { content: @fa-var-paw; }\r\n.@{fa-css-prefix}-spoon:before { content: @fa-var-spoon; }\r\n.@{fa-css-prefix}-cube:before { content: @fa-var-cube; }\r\n.@{fa-css-prefix}-cubes:before { content: @fa-var-cubes; }\r\n.@{fa-css-prefix}-behance:before { content: @fa-var-behance; }\r\n.@{fa-css-prefix}-behance-square:before { content: @fa-var-behance-square; }\r\n.@{fa-css-prefix}-steam:before { content: @fa-var-steam; }\r\n.@{fa-css-prefix}-steam-square:before { content: @fa-var-steam-square; }\r\n.@{fa-css-prefix}-recycle:before { content: @fa-var-recycle; }\r\n.@{fa-css-prefix}-automobile:before,\r\n.@{fa-css-prefix}-car:before { content: @fa-var-car; }\r\n.@{fa-css-prefix}-cab:before,\r\n.@{fa-css-prefix}-taxi:before { content: @fa-var-taxi; }\r\n.@{fa-css-prefix}-tree:before { content: @fa-var-tree; }\r\n.@{fa-css-prefix}-spotify:before { content: @fa-var-spotify; }\r\n.@{fa-css-prefix}-deviantart:before { content: @fa-var-deviantart; }\r\n.@{fa-css-prefix}-soundcloud:before { content: @fa-var-soundcloud; }\r\n.@{fa-css-prefix}-database:before { content: @fa-var-database; }\r\n.@{fa-css-prefix}-file-pdf-o:before { content: @fa-var-file-pdf-o; }\r\n.@{fa-css-prefix}-file-word-o:before { content: @fa-var-file-word-o; }\r\n.@{fa-css-prefix}-file-excel-o:before { content: @fa-var-file-excel-o; }\r\n.@{fa-css-prefix}-file-powerpoint-o:before { content: @fa-var-file-powerpoint-o; }\r\n.@{fa-css-prefix}-file-photo-o:before,\r\n.@{fa-css-prefix}-file-picture-o:before,\r\n.@{fa-css-prefix}-file-image-o:before { content: @fa-var-file-image-o; }\r\n.@{fa-css-prefix}-file-zip-o:before,\r\n.@{fa-css-prefix}-file-archive-o:before { content: @fa-var-file-archive-o; }\r\n.@{fa-css-prefix}-file-sound-o:before,\r\n.@{fa-css-prefix}-file-audio-o:before { content: @fa-var-file-audio-o; }\r\n.@{fa-css-prefix}-file-movie-o:before,\r\n.@{fa-css-prefix}-file-video-o:before { content: @fa-var-file-video-o; }\r\n.@{fa-css-prefix}-file-code-o:before { content: @fa-var-file-code-o; }\r\n.@{fa-css-prefix}-vine:before { content: @fa-var-vine; }\r\n.@{fa-css-prefix}-codepen:before { content: @fa-var-codepen; }\r\n.@{fa-css-prefix}-jsfiddle:before { content: @fa-var-jsfiddle; }\r\n.@{fa-css-prefix}-life-bouy:before,\r\n.@{fa-css-prefix}-life-buoy:before,\r\n.@{fa-css-prefix}-life-saver:before,\r\n.@{fa-css-prefix}-support:before,\r\n.@{fa-css-prefix}-life-ring:before { content: @fa-var-life-ring; }\r\n.@{fa-css-prefix}-circle-o-notch:before { content: @fa-var-circle-o-notch; }\r\n.@{fa-css-prefix}-ra:before,\r\n.@{fa-css-prefix}-rebel:before { content: @fa-var-rebel; }\r\n.@{fa-css-prefix}-ge:before,\r\n.@{fa-css-prefix}-empire:before { content: @fa-var-empire; }\r\n.@{fa-css-prefix}-git-square:before { content: @fa-var-git-square; }\r\n.@{fa-css-prefix}-git:before { content: @fa-var-git; }\r\n.@{fa-css-prefix}-hacker-news:before { content: @fa-var-hacker-news; }\r\n.@{fa-css-prefix}-tencent-weibo:before { content: @fa-var-tencent-weibo; }\r\n.@{fa-css-prefix}-qq:before { content: @fa-var-qq; }\r\n.@{fa-css-prefix}-wechat:before,\r\n.@{fa-css-prefix}-weixin:before { content: @fa-var-weixin; }\r\n.@{fa-css-prefix}-send:before,\r\n.@{fa-css-prefix}-paper-plane:before { content: @fa-var-paper-plane; }\r\n.@{fa-css-prefix}-send-o:before,\r\n.@{fa-css-prefix}-paper-plane-o:before { content: @fa-var-paper-plane-o; }\r\n.@{fa-css-prefix}-history:before { content: @fa-var-history; }\r\n.@{fa-css-prefix}-genderless:before,\r\n.@{fa-css-prefix}-circle-thin:before { content: @fa-var-circle-thin; }\r\n.@{fa-css-prefix}-header:before { content: @fa-var-header; }\r\n.@{fa-css-prefix}-paragraph:before { content: @fa-var-paragraph; }\r\n.@{fa-css-prefix}-sliders:before { content: @fa-var-sliders; }\r\n.@{fa-css-prefix}-share-alt:before { content: @fa-var-share-alt; }\r\n.@{fa-css-prefix}-share-alt-square:before { content: @fa-var-share-alt-square; }\r\n.@{fa-css-prefix}-bomb:before { content: @fa-var-bomb; }\r\n.@{fa-css-prefix}-soccer-ball-o:before,\r\n.@{fa-css-prefix}-futbol-o:before { content: @fa-var-futbol-o; }\r\n.@{fa-css-prefix}-tty:before { content: @fa-var-tty; }\r\n.@{fa-css-prefix}-binoculars:before { content: @fa-var-binoculars; }\r\n.@{fa-css-prefix}-plug:before { content: @fa-var-plug; }\r\n.@{fa-css-prefix}-slideshare:before { content: @fa-var-slideshare; }\r\n.@{fa-css-prefix}-twitch:before { content: @fa-var-twitch; }\r\n.@{fa-css-prefix}-yelp:before { content: @fa-var-yelp; }\r\n.@{fa-css-prefix}-newspaper-o:before { content: @fa-var-newspaper-o; }\r\n.@{fa-css-prefix}-wifi:before { content: @fa-var-wifi; }\r\n.@{fa-css-prefix}-calculator:before { content: @fa-var-calculator; }\r\n.@{fa-css-prefix}-paypal:before { content: @fa-var-paypal; }\r\n.@{fa-css-prefix}-google-wallet:before { content: @fa-var-google-wallet; }\r\n.@{fa-css-prefix}-cc-visa:before { content: @fa-var-cc-visa; }\r\n.@{fa-css-prefix}-cc-mastercard:before { content: @fa-var-cc-mastercard; }\r\n.@{fa-css-prefix}-cc-discover:before { content: @fa-var-cc-discover; }\r\n.@{fa-css-prefix}-cc-amex:before { content: @fa-var-cc-amex; }\r\n.@{fa-css-prefix}-cc-paypal:before { content: @fa-var-cc-paypal; }\r\n.@{fa-css-prefix}-cc-stripe:before { content: @fa-var-cc-stripe; }\r\n.@{fa-css-prefix}-bell-slash:before { content: @fa-var-bell-slash; }\r\n.@{fa-css-prefix}-bell-slash-o:before { content: @fa-var-bell-slash-o; }\r\n.@{fa-css-prefix}-trash:before { content: @fa-var-trash; }\r\n.@{fa-css-prefix}-copyright:before { content: @fa-var-copyright; }\r\n.@{fa-css-prefix}-at:before { content: @fa-var-at; }\r\n.@{fa-css-prefix}-eyedropper:before { content: @fa-var-eyedropper; }\r\n.@{fa-css-prefix}-paint-brush:before { content: @fa-var-paint-brush; }\r\n.@{fa-css-prefix}-birthday-cake:before { content: @fa-var-birthday-cake; }\r\n.@{fa-css-prefix}-area-chart:before { content: @fa-var-area-chart; }\r\n.@{fa-css-prefix}-pie-chart:before { content: @fa-var-pie-chart; }\r\n.@{fa-css-prefix}-line-chart:before { content: @fa-var-line-chart; }\r\n.@{fa-css-prefix}-lastfm:before { content: @fa-var-lastfm; }\r\n.@{fa-css-prefix}-lastfm-square:before { content: @fa-var-lastfm-square; }\r\n.@{fa-css-prefix}-toggle-off:before { content: @fa-var-toggle-off; }\r\n.@{fa-css-prefix}-toggle-on:before { content: @fa-var-toggle-on; }\r\n.@{fa-css-prefix}-bicycle:before { content: @fa-var-bicycle; }\r\n.@{fa-css-prefix}-bus:before { content: @fa-var-bus; }\r\n.@{fa-css-prefix}-ioxhost:before { content: @fa-var-ioxhost; }\r\n.@{fa-css-prefix}-angellist:before { content: @fa-var-angellist; }\r\n.@{fa-css-prefix}-cc:before { content: @fa-var-cc; }\r\n.@{fa-css-prefix}-shekel:before,\r\n.@{fa-css-prefix}-sheqel:before,\r\n.@{fa-css-prefix}-ils:before { content: @fa-var-ils; }\r\n.@{fa-css-prefix}-meanpath:before { content: @fa-var-meanpath; }\r\n.@{fa-css-prefix}-buysellads:before { content: @fa-var-buysellads; }\r\n.@{fa-css-prefix}-connectdevelop:before { content: @fa-var-connectdevelop; }\r\n.@{fa-css-prefix}-dashcube:before { content: @fa-var-dashcube; }\r\n.@{fa-css-prefix}-forumbee:before { content: @fa-var-forumbee; }\r\n.@{fa-css-prefix}-leanpub:before { content: @fa-var-leanpub; }\r\n.@{fa-css-prefix}-sellsy:before { content: @fa-var-sellsy; }\r\n.@{fa-css-prefix}-shirtsinbulk:before { content: @fa-var-shirtsinbulk; }\r\n.@{fa-css-prefix}-simplybuilt:before { content: @fa-var-simplybuilt; }\r\n.@{fa-css-prefix}-skyatlas:before { content: @fa-var-skyatlas; }\r\n.@{fa-css-prefix}-cart-plus:before { content: @fa-var-cart-plus; }\r\n.@{fa-css-prefix}-cart-arrow-down:before { content: @fa-var-cart-arrow-down; }\r\n.@{fa-css-prefix}-diamond:before { content: @fa-var-diamond; }\r\n.@{fa-css-prefix}-ship:before { content: @fa-var-ship; }\r\n.@{fa-css-prefix}-user-secret:before { content: @fa-var-user-secret; }\r\n.@{fa-css-prefix}-motorcycle:before { content: @fa-var-motorcycle; }\r\n.@{fa-css-prefix}-street-view:before { content: @fa-var-street-view; }\r\n.@{fa-css-prefix}-heartbeat:before { content: @fa-var-heartbeat; }\r\n.@{fa-css-prefix}-venus:before { content: @fa-var-venus; }\r\n.@{fa-css-prefix}-mars:before { content: @fa-var-mars; }\r\n.@{fa-css-prefix}-mercury:before { content: @fa-var-mercury; }\r\n.@{fa-css-prefix}-transgender:before { content: @fa-var-transgender; }\r\n.@{fa-css-prefix}-transgender-alt:before { content: @fa-var-transgender-alt; }\r\n.@{fa-css-prefix}-venus-double:before { content: @fa-var-venus-double; }\r\n.@{fa-css-prefix}-mars-double:before { content: @fa-var-mars-double; }\r\n.@{fa-css-prefix}-venus-mars:before { content: @fa-var-venus-mars; }\r\n.@{fa-css-prefix}-mars-stroke:before { content: @fa-var-mars-stroke; }\r\n.@{fa-css-prefix}-mars-stroke-v:before { content: @fa-var-mars-stroke-v; }\r\n.@{fa-css-prefix}-mars-stroke-h:before { content: @fa-var-mars-stroke-h; }\r\n.@{fa-css-prefix}-neuter:before { content: @fa-var-neuter; }\r\n.@{fa-css-prefix}-facebook-official:before { content: @fa-var-facebook-official; }\r\n.@{fa-css-prefix}-pinterest-p:before { content: @fa-var-pinterest-p; }\r\n.@{fa-css-prefix}-whatsapp:before { content: @fa-var-whatsapp; }\r\n.@{fa-css-prefix}-server:before { content: @fa-var-server; }\r\n.@{fa-css-prefix}-user-plus:before { content: @fa-var-user-plus; }\r\n.@{fa-css-prefix}-user-times:before { content: @fa-var-user-times; }\r\n.@{fa-css-prefix}-hotel:before,\r\n.@{fa-css-prefix}-bed:before { content: @fa-var-bed; }\r\n.@{fa-css-prefix}-viacoin:before { content: @fa-var-viacoin; }\r\n.@{fa-css-prefix}-train:before { content: @fa-var-train; }\r\n.@{fa-css-prefix}-subway:before { content: @fa-var-subway; }\r\n.@{fa-css-prefix}-medium:before { content: @fa-var-medium; }\r\n"],"sourceRoot":"/source/"} */ +/*# sourceMappingURL=data:application/json;base64,{"version":3,"sources":["Lib.css","bootstrap.less","mixins/vendor-prefixes.less","scaffolding.less","mixins/tab-focus.less","mixins/image.less","mixins/grid.less","grid.less","mixins/grid-framework.less","mixins/clearfix.less","utilities.less","mixins/center-block.less","mixins/hide-text.less","path.less","core.less","larger.less","fixed-width.less","list.less","bordered-pulled.less","animated.less","rotated-flipped.less","mixins.less","stacked.less","icons.less"],"names":[],"mappings":"AAAA;AACA;AACA;AACA;AACA;AACA,ACAA;ECuEU,uBAAA;CFxET;ACCD;;ECuEU,uBAAA;CFlET;ACLD;EEiBE,gBAAA;EACA,8CAAA;CHTD;ACTD;EEsBE,4DAAA;EACA,gBAAA;EACA,wBAAA;EACA,eAAA;EACA,uBAAA;CHVD;AChBD;;;;EEkCE,qBAAA;EACA,mBAAA;EACA,qBAAA;CHZD;ACxBD;EE2CE,eAAA;EACA,sBAAA;CHhBD;AGkBC;;EAEE,eAAA;EACA,2BAAA;CHhBH;AGmBC;ECrDA,qBAAA;EAEA,2CAAA;EACA,qBAAA;CJoCD;ACtCD;EEgEE,UAAA;CHvBD;ACzCD;EEuEE,uBAAA;CH3BD;AC5CD;EIIE,eAAA;EACA,gBAAA;EACA,aAAA;CL2CD;ACjDD;EEiFE,mBAAA;CH7BD;ACpDD;EEwFE,aAAA;EACA,wBAAA;EACA,uBAAA;EACA,uBAAA;EACA,mBAAA;ED+FQ,iCAAA;EGvLR,sBAAA;EACA,gBAAA;EACA,aAAA;CL2DD;ACjED;EEqGE,mBAAA;CHjCD;ACpED;EE4GE,iBAAA;EACA,oBAAA;EACA,UAAA;EACA,8BAAA;CHrCD;AC1ED;EEwHE,mBAAA;EACA,WAAA;EACA,YAAA;EACA,aAAA;EACA,WAAA;EACA,iBAAA;EACA,uBAAA;EACA,UAAA;CH3CD;AGmDC;;EAEE,iBAAA;EACA,YAAA;EACA,aAAA;EACA,UAAA;EACA,kBAAA;EACA,WAAA;CHjDH;AC7FD;EKCE,mBAAA;EACA,kBAAA;EACA,mBAAA;EACA,oBAAA;CN+FD;AOzFC;EAqEF;IAvEI,aAAA;GP+FD;CACF;AO3FC;EAkEF;IApEI,aAAA;GPiGD;CACF;AO7FD;EA+DA;IAjEI,cAAA;GPmGD;CACF;AClHD;EKCE,mBAAA;EACA,kBAAA;EACA,mBAAA;EACA,oBAAA;CNoHD;ACxHD;EKUE,mBAAA;EACA,oBAAA;CNiHD;AC5HD;EOYM,mBAAA;EAEA,gBAAA;EAEA,mBAAA;EACA,oBAAA;CRiHL;AClID;EOkCM,YAAA;CRmGL;ACrID;EO0CI,YAAA;CR8FH;ACxID;EO0CI,oBAAA;CRiGH;AC3ID;EO0CI,oBAAA;CRoGH;AC9ID;EO0CI,WAAA;CRuGH;ACjJD;EO0CI,oBAAA;CR0GH;ACpJD;EO0CI,oBAAA;CR6GH;ACvJD;EO0CI,WAAA;CRgHH;AC1JD;EO0CI,oBAAA;CRmHH;AC7JD;EO0CI,oBAAA;CRsHH;AChKD;EO0CI,WAAA;CRyHH;ACnKD;EO0CI,oBAAA;CR4HH;ACtKD;EO0CI,mBAAA;CR+HH;ACzKD;EOyDI,YAAA;CRmHH;AC5KD;EOyDI,oBAAA;CRsHH;AC/KD;EOyDI,oBAAA;CRyHH;AClLD;EOyDI,WAAA;CR4HH;ACrLD;EOyDI,oBAAA;CR+HH;ACxLD;EOyDI,oBAAA;CRkIH;AC3LD;EOyDI,WAAA;CRqIH;AC9LD;EOyDI,oBAAA;CRwIH;ACjMD;EOyDI,oBAAA;CR2IH;ACpMD;EOyDI,WAAA;CR8IH;ACvMD;EOyDI,oBAAA;CRiJH;AC1MD;EOyDI,mBAAA;CRoJH;AC7MD;EO8DI,YAAA;CRkJH;AChND;EO+CI,WAAA;CRoKH;ACnND;EO+CI,mBAAA;CRuKH;ACtND;EO+CI,mBAAA;CR0KH;ACzND;EO+CI,UAAA;CR6KH;AC5ND;EO+CI,mBAAA;CRgLH;AC/ND;EO+CI,mBAAA;CRmLH;AClOD;EO+CI,UAAA;CRsLH;ACrOD;EO+CI,mBAAA;CRyLH;ACxOD;EO+CI,mBAAA;CR4LH;AC3OD;EO+CI,UAAA;CR+LH;AC9OD;EO+CI,mBAAA;CRkMH;ACjPD;EO+CI,kBAAA;CRqMH;ACpPD;EOoDI,WAAA;CRmMH;ACvPD;EOmEI,kBAAA;CRuLH;AC1PD;EOmEI,0BAAA;CR0LH;AC7PD;EOmEI,0BAAA;CR6LH;AChQD;EOmEI,iBAAA;CRgMH;ACnQD;EOmEI,0BAAA;CRmMH;ACtQD;EOmEI,0BAAA;CRsMH;ACzQD;EOmEI,iBAAA;CRyMH;AC5QD;EOmEI,0BAAA;CR4MH;AC/QD;EOmEI,0BAAA;CR+MH;AClRD;EOmEI,iBAAA;CRkNH;ACrRD;EOmEI,0BAAA;CRqNH;ACxRD;EOmEI,yBAAA;CRwNH;AC3RD;EOmEI,gBAAA;CR2NH;AO3ND;EAYA;IC7CM,YAAA;GRgQH;EOnNH;ICrCI,YAAA;GR2PD;EOtNH;ICrCI,oBAAA;GR8PD;EOzNH;ICrCI,oBAAA;GRiQD;EO5NH;ICrCI,WAAA;GRoQD;EO/NH;ICrCI,oBAAA;GRuQD;EOlOH;ICrCI,oBAAA;GR0QD;EOrOH;ICrCI,WAAA;GR6QD;EOxOH;ICrCI,oBAAA;GRgRD;EO3OH;ICrCI,oBAAA;GRmRD;EO9OH;ICrCI,WAAA;GRsRD;EOjPH;ICrCI,oBAAA;GRyRD;EOpPH;ICrCI,mBAAA;GR4RD;EOvPH;ICtBI,YAAA;GRgRD;EO1PH;ICtBI,oBAAA;GRmRD;EO7PH;ICtBI,oBAAA;GRsRD;EOhQH;ICtBI,WAAA;GRyRD;EOnQH;ICtBI,oBAAA;GR4RD;EOtQH;ICtBI,oBAAA;GR+RD;EOzQH;ICtBI,WAAA;GRkSD;EO5QH;ICtBI,oBAAA;GRqSD;EO/QH;ICtBI,oBAAA;GRwSD;EOlRH;ICtBI,WAAA;GR2SD;EOrRH;ICtBI,oBAAA;GR8SD;EOxRH;ICtBI,mBAAA;GRiTD;EO3RH;ICjBI,YAAA;GR+SD;EO9RH;IChCI,WAAA;GRiUD;EOjSH;IChCI,mBAAA;GRoUD;EOpSH;IChCI,mBAAA;GRuUD;EOvSH;IChCI,UAAA;GR0UD;EO1SH;IChCI,mBAAA;GR6UD;EO7SH;IChCI,mBAAA;GRgVD;EOhTH;IChCI,UAAA;GRmVD;EOnTH;IChCI,mBAAA;GRsVD;EOtTH;IChCI,mBAAA;GRyVD;EOzTH;IChCI,UAAA;GR4VD;EO5TH;IChCI,mBAAA;GR+VD;EO/TH;IChCI,kBAAA;GRkWD;EOlUH;IC3BI,WAAA;GRgWD;EOrUH;ICZI,kBAAA;GRoVD;EOxUH;ICZI,0BAAA;GRuVD;EO3UH;ICZI,0BAAA;GR0VD;EO9UH;ICZI,iBAAA;GR6VD;EOjVH;ICZI,0BAAA;GRgWD;EOpVH;ICZI,0BAAA;GRmWD;EOvVH;ICZI,iBAAA;GRsWD;EO1VH;ICZI,0BAAA;GRyWD;EO7VH;ICZI,0BAAA;GR4WD;EOhWH;ICZI,iBAAA;GR+WD;EOnWH;ICZI,0BAAA;GRkXD;EOtWH;ICZI,yBAAA;GRqXD;EOzWH;ICZI,gBAAA;GRwXD;CACF;AOhXD;EAGA;IC7CM,YAAA;GR8ZH;EOjXH;ICrCI,YAAA;GRyZD;EOpXH;ICrCI,oBAAA;GR4ZD;EOvXH;ICrCI,oBAAA;GR+ZD;EO1XH;ICrCI,WAAA;GRkaD;EO7XH;ICrCI,oBAAA;GRqaD;EOhYH;ICrCI,oBAAA;GRwaD;EOnYH;ICrCI,WAAA;GR2aD;EOtYH;ICrCI,oBAAA;GR8aD;EOzYH;ICrCI,oBAAA;GRibD;EO5YH;ICrCI,WAAA;GRobD;EO/YH;ICrCI,oBAAA;GRubD;EOlZH;ICrCI,mBAAA;GR0bD;EOrZH;ICtBI,YAAA;GR8aD;EOxZH;ICtBI,oBAAA;GRibD;EO3ZH;ICtBI,oBAAA;GRobD;EO9ZH;ICtBI,WAAA;GRubD;EOjaH;ICtBI,oBAAA;GR0bD;EOpaH;ICtBI,oBAAA;GR6bD;EOvaH;ICtBI,WAAA;GRgcD;EO1aH;ICtBI,oBAAA;GRmcD;EO7aH;ICtBI,oBAAA;GRscD;EOhbH;ICtBI,WAAA;GRycD;EOnbH;ICtBI,oBAAA;GR4cD;EOtbH;ICtBI,mBAAA;GR+cD;EOzbH;ICjBI,YAAA;GR6cD;EO5bH;IChCI,WAAA;GR+dD;EO/bH;IChCI,mBAAA;GRkeD;EOlcH;IChCI,mBAAA;GRqeD;EOrcH;IChCI,UAAA;GRweD;EOxcH;IChCI,mBAAA;GR2eD;EO3cH;IChCI,mBAAA;GR8eD;EO9cH;IChCI,UAAA;GRifD;EOjdH;IChCI,mBAAA;GRofD;EOpdH;IChCI,mBAAA;GRufD;EOvdH;IChCI,UAAA;GR0fD;EO1dH;IChCI,mBAAA;GR6fD;EO7dH;IChCI,kBAAA;GRggBD;EOheH;IC3BI,WAAA;GR8fD;EOneH;ICZI,kBAAA;GRkfD;EOteH;ICZI,0BAAA;GRqfD;EOzeH;ICZI,0BAAA;GRwfD;EO5eH;ICZI,iBAAA;GR2fD;EO/eH;ICZI,0BAAA;GR8fD;EOlfH;ICZI,0BAAA;GRigBD;EOrfH;ICZI,iBAAA;GRogBD;EOxfH;ICZI,0BAAA;GRugBD;EO3fH;ICZI,0BAAA;GR0gBD;EO9fH;ICZI,iBAAA;GR6gBD;EOjgBH;ICZI,0BAAA;GRghBD;EOpgBH;ICZI,yBAAA;GRmhBD;EOvgBH;ICZI,gBAAA;GRshBD;CACF;AO3gBD;EAAA;IC7CM,YAAA;GR4jBH;EO/gBH;ICrCI,YAAA;GRujBD;EOlhBH;ICrCI,oBAAA;GR0jBD;EOrhBH;ICrCI,oBAAA;GR6jBD;EOxhBH;ICrCI,WAAA;GRgkBD;EO3hBH;ICrCI,oBAAA;GRmkBD;EO9hBH;ICrCI,oBAAA;GRskBD;EOjiBH;ICrCI,WAAA;GRykBD;EOpiBH;ICrCI,oBAAA;GR4kBD;EOviBH;ICrCI,oBAAA;GR+kBD;EO1iBH;ICrCI,WAAA;GRklBD;EO7iBH;ICrCI,oBAAA;GRqlBD;EOhjBH;ICrCI,mBAAA;GRwlBD;EOnjBH;ICtBI,YAAA;GR4kBD;EOtjBH;ICtBI,oBAAA;GR+kBD;EOzjBH;ICtBI,oBAAA;GRklBD;EO5jBH;ICtBI,WAAA;GRqlBD;EO/jBH;ICtBI,oBAAA;GRwlBD;EOlkBH;ICtBI,oBAAA;GR2lBD;EOrkBH;ICtBI,WAAA;GR8lBD;EOxkBH;ICtBI,oBAAA;GRimBD;EO3kBH;ICtBI,oBAAA;GRomBD;EO9kBH;ICtBI,WAAA;GRumBD;EOjlBH;ICtBI,oBAAA;GR0mBD;EOplBH;ICtBI,mBAAA;GR6mBD;EOvlBH;ICjBI,YAAA;GR2mBD;EO1lBH;IChCI,WAAA;GR6nBD;EO7lBH;IChCI,mBAAA;GRgoBD;EOhmBH;IChCI,mBAAA;GRmoBD;EOnmBH;IChCI,UAAA;GRsoBD;EOtmBH;IChCI,mBAAA;GRyoBD;EOzmBH;IChCI,mBAAA;GR4oBD;EO5mBH;IChCI,UAAA;GR+oBD;EO/mBH;IChCI,mBAAA;GRkpBD;EOlnBH;IChCI,mBAAA;GRqpBD;EOrnBH;IChCI,UAAA;GRwpBD;EOxnBH;IChCI,mBAAA;GR2pBD;EO3nBH;IChCI,kBAAA;GR8pBD;EO9nBH;IC3BI,WAAA;GR4pBD;EOjoBH;ICZI,kBAAA;GRgpBD;EOpoBH;ICZI,0BAAA;GRmpBD;EOvoBH;ICZI,0BAAA;GRspBD;EO1oBH;ICZI,iBAAA;GRypBD;EO7oBH;ICZI,0BAAA;GR4pBD;EOhpBH;ICZI,0BAAA;GR+pBD;EOnpBH;ICZI,iBAAA;GRkqBD;EOtpBH;ICZI,0BAAA;GRqqBD;EOzpBH;ICZI,0BAAA;GRwqBD;EO5pBH;ICZI,iBAAA;GR2qBD;EO/pBH;ICZI,0BAAA;GR8qBD;EOlqBH;ICZI,yBAAA;GRirBD;EOrqBH;ICZI,gBAAA;GRorBD;CACF;AShvBC;;;;;;;;EAEE,aAAA;EACA,eAAA;CTwvBH;AStvBC;;;;EACE,YAAA;CT2vBH;AUnwBD;ECRE,eAAA;EACA,kBAAA;EACA,mBAAA;CX8wBD;AUrwBD;EACE,wBAAA;CVuwBD;AUrwBD;EACE,uBAAA;CVuwBD;AU/vBD;EACE,yBAAA;CViwBD;AU/vBD;EACE,0BAAA;CViwBD;AU/vBD;EACE,mBAAA;CViwBD;AU/vBD;EEzBE,YAAA;EACA,mBAAA;EACA,kBAAA;EACA,8BAAA;EACA,UAAA;CZ2xBD;AU7vBD;EACE,yBAAA;EACA,8BAAA;CV+vBD;AUxvBD;EACE,gBAAA;CV0vBD;;AAED;;;GAGG;AACH;gCACgC;AapzBhC;EACE,2BAAA;EACA,kDAAA;EACA,mWAAA;EAMA,oBAAA;EACA,mBAAA;CbizBD;Ac3zBD;EACE,sBAAA;EACA,8CAAA;EACA,mBAAA;EACA,qBAAA;EACA,oCAAA;EACA,mCAAA;EACA,mCAAA;UAAA,2BAAA;Cd6zBD;AACD,8DAA8D;Aep0B9D;EACE,wBAAA;EACA,oBAAA;EACA,qBAAA;Cfs0BD;Aep0BD;EAAuB,eAAA;Cfu0BtB;Aet0BD;EAAuB,eAAA;Cfy0BtB;Aex0BD;EAAuB,eAAA;Cf20BtB;Ae10BD;EAAuB,eAAA;Cf60BtB;AgBv1BD;EACE,oBAAA;EACA,mBAAA;ChBy1BD;AiB11BD;EACE,gBAAA;EACA,0BAAA;EACA,sBAAA;CjB41BD;AiB/1BD;EAIS,mBAAA;CjB81BR;AiB51BD;EACE,mBAAA;EACA,oBAAA;EACA,oBAAA;EACA,kBAAA;EACA,mBAAA;CjB81BD;AiB71BC;EACE,oBAAA;CjB+1BH;AkB52BD;EACE,0BAAA;EACA,0BAAA;EACA,oBAAA;ClB82BD;AkB32BD;EAAc,aAAA;ClB82Bb;AkB72BD;EAAa,YAAA;ClBg3BZ;AkB72BC;EAAc,mBAAA;ClBg3Bf;AkB/2BC;EAAe,kBAAA;ClBk3BhB;AmB73BD;EACE,8CAAA;EACQ,sCAAA;CnB+3BT;AmB53BD;EACE,gDAAA;EACQ,wCAAA;CnB83BT;AmB33BD;EACE;IACE,gCAAA;IACQ,wBAAA;GnB63BT;EmB33BD;IACE,kCAAA;IACQ,0BAAA;GnB63BT;CACF;AmB13BD;EACE;IACE,gCAAA;IACQ,wBAAA;GnB43BT;EmB13BD;IACE,kCAAA;IACQ,0BAAA;GnB43BT;CACF;AoBz5BD;ECYE,iEAAA;EACA,iCAAA;EAEQ,yBAAA;CrBg5BT;AoB95BD;ECWE,iEAAA;EACA,kCAAA;EAEQ,0BAAA;CrBs5BT;AoBn6BD;ECUE,iEAAA;EACA,kCAAA;EAEQ,0BAAA;CrB45BT;AoBv6BD;ECeE,2EAAA;EACA,gCAAA;EAEQ,wBAAA;CrB25BT;AoB56BD;ECcE,2EAAA;EACA,gCAAA;EAEQ,wBAAA;CrBi6BT;AoB76BD;;;;;EAKE,qBAAA;UAAA,aAAA;CpB+6BD;AsB97BD;EACE,mBAAA;EACA,sBAAA;EACA,WAAA;EACA,YAAA;EACA,iBAAA;EACA,uBAAA;CtBg8BD;AsB97BD;;EACE,mBAAA;EACA,QAAA;EACA,YAAA;EACA,mBAAA;CtBi8BD;AsB/7BD;EAA6B,qBAAA;CtBk8B5B;AsBj8BD;EAA6B,eAAA;CtBo8B5B;AsBn8BD;EAA4B,YAAA;CtBs8B3B;AACD;oEACoE;AuBx9BpE;EAAiC,iBAAA;CvB29BhC;AuB19BD;EAAiC,iBAAA;CvB69BhC;AuB59BD;EAAkC,iBAAA;CvB+9BjC;AuB99BD;EAAsC,iBAAA;CvBi+BrC;AuBh+BD;EAAiC,iBAAA;CvBm+BhC;AuBl+BD;EAAgC,iBAAA;CvBq+B/B;AuBp+BD;EAAkC,iBAAA;CvBu+BjC;AuBt+BD;EAAgC,iBAAA;CvBy+B/B;AuBx+BD;EAAgC,iBAAA;CvB2+B/B;AuB1+BD;EAAoC,iBAAA;CvB6+BnC;AuB5+BD;EAA8B,iBAAA;CvB++B7B;AuB9+BD;EAAmC,iBAAA;CvBi/BlC;AuBh/BD;EAAiC,iBAAA;CvBm/BhC;AuBl/BD;;;EAEiC,iBAAA;CvBq/BhC;AuBp/BD;EAAuC,iBAAA;CvBu/BtC;AuBt/BD;EAAwC,iBAAA;CvBy/BvC;AuBx/BD;EAAqC,iBAAA;CvB2/BpC;AuB1/BD;EAAkC,iBAAA;CvB6/BjC;AuB5/BD;;EAC+B,iBAAA;CvB+/B9B;AuB9/BD;EAAmC,iBAAA;CvBigClC;AuBhgCD;EAAgC,iBAAA;CvBmgC/B;AuBlgCD;EAAkC,iBAAA;CvBqgCjC;AuBpgCD;EAAmC,iBAAA;CvBugClC;AuBtgCD;EAAgC,iBAAA;CvBygC/B;AuBxgCD;EAAoC,iBAAA;CvB2gCnC;AuB1gCD;EAA+C,iBAAA;CvB6gC9C;AuB5gCD;EAA6C,iBAAA;CvB+gC5C;AuB9gCD;EAAiC,iBAAA;CvBihChC;AuBhhCD;EAAyC,iBAAA;CvBmhCxC;AuBlhCD;;EACkC,iBAAA;CvBqhCjC;AuBphCD;EAAmC,iBAAA;CvBuhClC;AuBthCD;EAAoC,iBAAA;CvByhCnC;AuBxhCD;EAAgC,iBAAA;CvB2hC/B;AuB1hCD;EAAgC,iBAAA;CvB6hC/B;AuB5hCD;EAAsC,iBAAA;CvB+hCrC;AuB9hCD;EAAsC,iBAAA;CvBiiCrC;AuBhiCD;EAAuC,iBAAA;CvBmiCtC;AuBliCD;EAAqC,iBAAA;CvBqiCpC;AuBpiCD;EAAkC,iBAAA;CvBuiCjC;AuBtiCD;EAAmC,iBAAA;CvByiClC;AuBxiCD;EAA+B,iBAAA;CvB2iC9B;AuB1iCD;EAAgC,iBAAA;CvB6iC/B;AuB5iCD;EAAgC,iBAAA;CvB+iC/B;AuB9iCD;EAAoC,iBAAA;CvBijCnC;AuBhjCD;EAAiC,iBAAA;CvBmjChC;AuBljCD;EAAkC,iBAAA;CvBqjCjC;AuBpjCD;EAAgC,iBAAA;CvBujC/B;AuBtjCD;EAAgC,iBAAA;CvByjC/B;AuBxjCD;EAAkC,iBAAA;CvB2jCjC;AuB1jCD;EAAuC,iBAAA;CvB6jCtC;AuB5jCD;EAAsC,iBAAA;CvB+jCrC;AuB9jCD;EAAsC,iBAAA;CvBikCrC;AuBhkCD;EAAwC,iBAAA;CvBmkCvC;AuBlkCD;EAAuC,iBAAA;CvBqkCtC;AuBpkCD;EAAyC,iBAAA;CvBukCxC;AuBtkCD;EAAgC,iBAAA;CvBykC/B;AuBxkCD;;EACmC,iBAAA;CvB2kClC;AuB1kCD;EAAkC,iBAAA;CvB6kCjC;AuB5kCD;EAAwC,iBAAA;CvB+kCvC;AuB9kCD;;;EAEqC,iBAAA;CvBilCpC;AuBhlCD;EAAkC,iBAAA;CvBmlCjC;AuBllCD;EAAsC,iBAAA;CvBqlCrC;AuBplCD;EAAkC,iBAAA;CvBulCjC;AuBtlCD;EAAgC,iBAAA;CvBylC/B;AuBxlCD;;EAC2C,iBAAA;CvB2lC1C;AuB1lCD;EAA0C,iBAAA;CvB6lCzC;AuB5lCD;EAA0C,iBAAA;CvB+lCzC;AuB9lCD;EAAkC,iBAAA;CvBimCjC;AuBhmCD;EAAyC,iBAAA;CvBmmCxC;AuBlmCD;EAAyC,iBAAA;CvBqmCxC;AuBpmCD;EAAoC,iBAAA;CvBumCnC;AuBtmCD;EAAgC,iBAAA;CvBymC/B;AuBxmCD;EAAiC,iBAAA;CvB2mChC;AuB1mCD;EAAgC,iBAAA;CvB6mC/B;AuB5mCD;EAAmC,iBAAA;CvB+mClC;AuB9mCD;EAAwC,iBAAA;CvBinCvC;AuBhnCD;EAAwC,iBAAA;CvBmnCvC;AuBlnCD;EAAiC,iBAAA;CvBqnChC;AuBpnCD;EAAwC,iBAAA;CvBunCvC;AuBtnCD;EAAyC,iBAAA;CvBynCxC;AuBxnCD;EAAuC,iBAAA;CvB2nCtC;AuB1nCD;EAAwC,iBAAA;CvB6nCvC;AuB5nCD;EAAwC,iBAAA;CvB+nCvC;AuB9nCD;EAAwC,iBAAA;CvBioCvC;AuBhoCD;EAA2C,iBAAA;CvBmoC1C;AuBloCD;EAAuC,iBAAA;CvBqoCtC;AuBpoCD;EAAsC,iBAAA;CvBuoCrC;AuBtoCD;EAA0C,iBAAA;CvByoCzC;AuBxoCD;EAA0C,iBAAA;CvB2oCzC;AuB1oCD;EAA+B,iBAAA;CvB6oC9B;AuB5oCD;EAAsC,iBAAA;CvB+oCrC;AuB9oCD;EAAuC,iBAAA;CvBipCtC;AuBhpCD;EAAoC,iBAAA;CvBmpCnC;AuBlpCD;EAAsC,iBAAA;CvBqpCrC;AuBppCD;;EACiC,iBAAA;CvBupChC;AuBtpCD;EAAkC,iBAAA;CvBypCjC;AuBxpCD;EAAoC,iBAAA;CvB2pCnC;AuB1pCD;EAAgC,iBAAA;CvB6pC/B;AuB5pCD;EAAiC,iBAAA;CvB+pChC;AuB9pCD;EAAoC,iBAAA;CvBiqCnC;AuBhqCD;EAA8C,iBAAA;CvBmqC7C;AuBlqCD;EAAgC,iBAAA;CvBqqC/B;AuBpqCD;EAAgC,iBAAA;CvBuqC/B;AuBtqCD;EAAgC,iBAAA;CvByqC/B;AuBxqCD;EAA+B,iBAAA;CvB2qC9B;AuB1qCD;EAAqC,iBAAA;CvB6qCpC;AuB5qCD;;EACgD,iBAAA;CvB+qC/C;AuB9qCD;EAAiC,iBAAA;CvBirChC;AuBhrCD;EAAoC,iBAAA;CvBmrCnC;AuBlrCD;EAAkC,iBAAA;CvBqrCjC;AuBprCD;EAAmC,iBAAA;CvBurClC;AuBtrCD;EAAkC,iBAAA;CvByrCjC;AuBxrCD;EAAsC,iBAAA;CvB2rCrC;AuB1rCD;EAAwC,iBAAA;CvB6rCvC;AuB5rCD;EAAmC,iBAAA;CvB+rClC;AuB9rCD;EAAyC,iBAAA;CvBisCxC;AuBhsCD;EAAkC,iBAAA;CvBmsCjC;AuBlsCD;EAAuC,iBAAA;CvBqsCtC;AuBpsCD;EAAoC,iBAAA;CvBusCnC;AuBtsCD;EAAoC,iBAAA;CvBysCnC;AuBxsCD;;EACqC,iBAAA;CvB2sCpC;AuB1sCD;EAA0C,iBAAA;CvB6sCzC;AuB5sCD;EAA2C,iBAAA;CvB+sC1C;AuB9sCD;EAAwC,iBAAA;CvBitCvC;AuBhtCD;EAA+B,iBAAA;CvBmtC9B;AuBltCD;;EACgC,iBAAA;CvBqtC/B;AuBptCD;EAAoC,iBAAA;CvButCnC;AuBttCD;EAAuC,iBAAA;CvBytCtC;AuBxtCD;EAAyC,iBAAA;CvB2tCxC;AuB1tCD;EAAqC,iBAAA;CvB6tCpC;AuB5tCD;EAAmC,iBAAA;CvB+tClC;AuB9tCD;EAAoC,iBAAA;CvBiuCnC;AuBhuCD;EAA2C,iBAAA;CvBmuC1C;AuBluCD;EAAsC,iBAAA;CvBquCrC;AuBpuCD;EAAyC,iBAAA;CvBuuCxC;AuBtuCD;EAAmC,iBAAA;CvByuClC;AuBxuCD;EAAkC,iBAAA;CvB2uCjC;AuB1uCD;EAAyC,iBAAA;CvB6uCxC;AuB5uCD;EAAkC,iBAAA;CvB+uCjC;AuB9uCD;EAAmC,iBAAA;CvBivClC;AuBhvCD;EAAiC,iBAAA;CvBmvChC;AuBlvCD;EAAoC,iBAAA;CvBqvCnC;AuBpvCD;EAAsC,iBAAA;CvBuvCrC;AuBtvCD;EAAwC,iBAAA;CvByvCvC;AuBxvCD;EAAmC,iBAAA;CvB2vClC;AuB1vCD;;EACoC,iBAAA;CvB6vCnC;AuB5vCD;EAAkC,iBAAA;CvB+vCjC;AuB9vCD;EAAkC,iBAAA;CvBiwCjC;AuBhwCD;EAAuC,iBAAA;CvBmwCtC;AuBlwCD;EAA+B,iBAAA;CvBqwC9B;AuBpwCD;EAAiC,iBAAA;CvBuwChC;AuBtwCD;EAAoC,iBAAA;CvBywCnC;AuBxwCD;EAAgC,iBAAA;CvB2wC/B;AuB1wCD;EAAuC,iBAAA;CvB6wCtC;AuB5wCD;EAAwC,iBAAA;CvB+wCvC;AuB9wCD;EAAuC,iBAAA;CvBixCtC;AuBhxCD;EAAqC,iBAAA;CvBmxCpC;AuBlxCD;EAAuC,iBAAA;CvBqxCtC;AuBpxCD;EAA6C,iBAAA;CvBuxC5C;AuBtxCD;EAA8C,iBAAA;CvByxC7C;AuBxxCD;EAA2C,iBAAA;CvB2xC1C;AuB1xCD;EAA6C,iBAAA;CvB6xC5C;AuB5xCD;EAAiC,iBAAA;CvB+xChC;AuB9xCD;EAAkC,iBAAA;CvBiyCjC;AuBhyCD;EAAiC,iBAAA;CvBmyChC;AuBlyCD;EAAkC,iBAAA;CvBqyCjC;AuBpyCD;EAAqC,iBAAA;CvBuyCpC;AuBtyCD;EAAsC,iBAAA;CvByyCrC;AuBxyCD;;EACiC,iBAAA;CvB2yChC;AuB1yCD;;EACgC,iBAAA;CvB6yC/B;AuB5yCD;EAAiC,iBAAA;CvB+yChC;AuB9yCD;EAAiC,iBAAA;CvBizChC;AuBhzCD;;EACoC,iBAAA;CvBmzCnC;AuBlzCD;;EACmC,iBAAA;CvBqzClC;AuBpzCD;EAAqC,iBAAA;CvBuzCpC;AuBtzCD;;EACoC,iBAAA;CvByzCnC;AuBxzCD;EAAkC,iBAAA;CvB2zCjC;AuB1zCD;;;EAEgC,iBAAA;CvB6zC/B;AuB5zCD;EAAmC,iBAAA;CvB+zClC;AuB9zCD;EAAmC,iBAAA;CvBi0ClC;AuBh0CD;EAAyC,iBAAA;CvBm0CxC;AuBl0CD;EAAqC,iBAAA;CvBq0CpC;AuBp0CD;EAAiC,iBAAA;CvBu0ChC;AuBt0CD;EAAiC,iBAAA;CvBy0ChC;AuBx0CD;EAAiC,iBAAA;CvB20ChC;AuB10CD;EAAqC,iBAAA;CvB60CpC;AuB50CD;EAA4C,iBAAA;CvB+0C3C;AuB90CD;EAA8C,iBAAA;CvBi1C7C;AuBh1CD;EAAuC,iBAAA;CvBm1CtC;AuBl1CD;EAAiC,iBAAA;CvBq1ChC;AuBp1CD;EAAsC,iBAAA;CvBu1CrC;AuBt1CD;EAAoC,iBAAA;CvBy1CnC;AuBx1CD;EAAsC,iBAAA;CvB21CrC;AuB11CD;EAAuC,iBAAA;CvB61CtC;AuB51CD;EAAmC,iBAAA;CvB+1ClC;AuB91CD;;EACgC,iBAAA;CvBi2C/B;AuBh2CD;;EACqC,iBAAA;CvBm2CpC;AuBl2CD;;EACoC,iBAAA;CvBq2CnC;AuBp2CD;EAAoC,iBAAA;CvBu2CnC;AuBt2CD;EAAoC,iBAAA;CvBy2CnC;AuBx2CD;;EACgC,iBAAA;CvB22C/B;AuB12CD;;EACiC,iBAAA;CvB62ChC;AuB52CD;;EACsC,iBAAA;CvB+2CrC;AuB92CD;EAAqC,iBAAA;CvBi3CpC;AuBh3CD;EAAsC,iBAAA;CvBm3CrC;AuBl3CD;;EACgC,iBAAA;CvBq3C/B;AuBp3CD;EAAmC,iBAAA;CvBu3ClC;AuBt3CD;EAAoC,iBAAA;CvBy3CnC;AuBx3CD;;EACqC,iBAAA;CvB23CpC;AuB13CD;EAAuC,iBAAA;CvB63CtC;AuB53CD;EAAoC,iBAAA;CvB+3CnC;AuB93CD;EAA0C,iBAAA;CvBi4CzC;AuBh4CD;EAAwC,iBAAA;CvBm4CvC;AuBl4CD;EAAmC,iBAAA;CvBq4ClC;AuBp4CD;EAAuC,iBAAA;CvBu4CtC;AuBt4CD;EAAoC,iBAAA;CvBy4CnC;AuBx4CD;EAAkC,iBAAA;CvB24CjC;AuB14CD;EAAkC,iBAAA;CvB64CjC;AuB54CD;EAAmC,iBAAA;CvB+4ClC;AuB94CD;EAAuC,iBAAA;CvBi5CtC;AuBh5CD;EAAsC,iBAAA;CvBm5CrC;AuBl5CD;EAAsC,iBAAA;CvBq5CrC;AuBp5CD;EAAqC,iBAAA;CvBu5CpC;AuBt5CD;EAAkC,iBAAA;CvBy5CjC;AuBx5CD;EAAuC,iBAAA;CvB25CtC;AuB15CD;EAAgC,iBAAA;CvB65C/B;AuB55CD;EAAoC,iBAAA;CvB+5CnC;AuB95CD;EAAuC,iBAAA;CvBi6CtC;AuBh6CD;EAA6C,iBAAA;CvBm6C5C;AuBl6CD;EAA8C,iBAAA;CvBq6C7C;AuBp6CD;EAA2C,iBAAA;CvBu6C1C;AuBt6CD;EAA6C,iBAAA;CvBy6C5C;AuBx6CD;EAAsC,iBAAA;CvB26CrC;AuB16CD;EAAuC,iBAAA;CvB66CtC;AuB56CD;EAAoC,iBAAA;CvB+6CnC;AuB96CD;EAAsC,iBAAA;CvBi7CrC;AuBh7CD;EAAmC,iBAAA;CvBm7ClC;AuBl7CD;EAAkC,iBAAA;CvBq7CjC;AuBp7CD;EAAkC,iBAAA;CvBu7CjC;AuBt7CD;;EACkC,iBAAA;CvBy7CjC;AuBx7CD;EAAoC,iBAAA;CvB27CnC;AuB17CD;EAAsC,iBAAA;CvB67CrC;AuB57CD;EAAuC,iBAAA;CvB+7CtC;AuB97CD;EAAmC,iBAAA;CvBi8ClC;AuBh8CD;EAAkC,iBAAA;CvBm8CjC;AuBl8CD;;EACiC,iBAAA;CvBq8ChC;AuBp8CD;EAAsC,iBAAA;CvBu8CrC;AuBt8CD;EAAoC,iBAAA;CvBy8CnC;AuBx8CD;EAAyC,iBAAA;CvB28CxC;AuB18CD;EAAmC,iBAAA;CvB68ClC;AuB58CD;EAAmC,iBAAA;CvB+8ClC;AuB98CD;EAAiC,iBAAA;CvBi9ChC;AuBh9CD;EAAmC,iBAAA;CvBm9ClC;AuBl9CD;EAAsC,iBAAA;CvBq9CrC;AuBp9CD;EAAkC,iBAAA;CvBu9CjC;AuBt9CD;EAA0C,iBAAA;CvBy9CzC;AuBx9CD;EAAoC,iBAAA;CvB29CnC;AuB19CD;EAAgC,iBAAA;CvB69C/B;AuB59CD;;EACqC,iBAAA;CvB+9CpC;AuB99CD;;;EAEuC,iBAAA;CvBi+CtC;AuBh+CD;EAA0C,iBAAA;CvBm+CzC;AuBl+CD;EAAgC,iBAAA;CvBq+C/B;AuBp+CD;EAAqC,iBAAA;CvBu+CpC;AuBt+CD;;EACwC,iBAAA;CvBy+CvC;AuBx+CD;EAAoC,iBAAA;CvB2+CnC;AuB1+CD;EAAgC,iBAAA;CvB6+C/B;AuB5+CD;EAAuC,iBAAA;CvB++CtC;AuB9+CD;EAAuC,iBAAA;CvBi/CtC;AuBh/CD;EAAqC,iBAAA;CvBm/CpC;AuBl/CD;EAAkC,iBAAA;CvBq/CjC;AuBp/CD;EAAwC,iBAAA;CvBu/CvC;AuBt/CD;EAAsC,iBAAA;CvBy/CrC;AuBx/CD;EAA4C,iBAAA;CvB2/C3C;AuB1/CD;EAAkC,iBAAA;CvB6/CjC;AuB5/CD;EAAsC,iBAAA;CvB+/CrC;AuB9/CD;EAA6C,iBAAA;CvBigD5C;AuBhgDD;EAAkC,iBAAA;CvBmgDjC;AuBlgDD;EAAkC,iBAAA;CvBqgDjC;AuBpgDD;EAA+C,iBAAA;CvBugD9C;AuBtgDD;EAAgD,iBAAA;CvBygD/C;AuBxgDD;EAA6C,iBAAA;CvB2gD5C;AuB1gDD;EAA+C,iBAAA;CvB6gD9C;AuB5gDD;EAAiC,iBAAA;CvB+gDhC;AuB9gDD;EAAgC,iBAAA;CvBihD/B;AuBhhDD;EAAkC,iBAAA;CvBmhDjC;AuBlhDD;EAAsC,iBAAA;CvBqhDrC;AuBphDD;EAAoC,iBAAA;CvBuhDnC;AuBthDD;EAAsC,iBAAA;CvByhDrC;AuBxhDD;EAAsC,iBAAA;CvB2hDrC;AuB1hDD;EAAsC,iBAAA;CvB6hDrC;AuB5hDD;EAAuC,iBAAA;CvB+hDtC;AuB9hDD;EAAkC,iBAAA;CvBiiDjC;AuBhiDD;EAAwC,iBAAA;CvBmiDvC;AuBliDD;EAA0C,iBAAA;CvBqiDzC;AuBpiDD;EAAoC,iBAAA;CvBuiDnC;AuBtiDD;EAAsC,iBAAA;CvByiDrC;AuBxiDD;EAAwC,iBAAA;CvB2iDvC;AuB1iDD;EAAyC,iBAAA;CvB6iDxC;AuB5iDD;EAAgD,iBAAA;CvB+iD/C;AuB9iDD;EAAwC,iBAAA;CvBijDvC;AuBhjDD;EAAmC,iBAAA;CvBmjDlC;AuBljDD;;EAC+C,iBAAA;CvBqjD9C;AuBpjDD;;EAC6C,iBAAA;CvBujD5C;AuBtjDD;;EACgD,iBAAA;CvByjD/C;AuBxjDD;;EAC+B,iBAAA;CvB2jD9B;AuB1jDD;EAA+B,iBAAA;CvB6jD9B;AuB5jDD;;EAC+B,iBAAA;CvB+jD9B;AuB9jDD;;EAC+B,iBAAA;CvBikD9B;AuBhkDD;;;;EAG+B,iBAAA;CvBmkD9B;AuBlkDD;;;EAE+B,iBAAA;CvBqkD9B;AuBpkDD;;EAC+B,iBAAA;CvBukD9B;AuBtkDD;;EAC+B,iBAAA;CvBykD9B;AuBxkDD;EAAgC,iBAAA;CvB2kD/B;AuB1kDD;EAAqC,iBAAA;CvB6kDpC;AuB5kDD;EAA0C,iBAAA;CvB+kDzC;AuB9kDD;EAA2C,iBAAA;CvBilD1C;AuBhlDD;EAA2C,iBAAA;CvBmlD1C;AuBllDD;EAA4C,iBAAA;CvBqlD3C;AuBplDD;EAA4C,iBAAA;CvBulD3C;AuBtlDD;EAA6C,iBAAA;CvBylD5C;AuBxlDD;EAAqC,iBAAA;CvB2lDpC;AuB1lDD;EAAuC,iBAAA;CvB6lDtC;AuB5lDD;EAA0C,iBAAA;CvB+lDzC;AuB9lDD;EAAmC,iBAAA;CvBimDlC;AuBhmDD;EAAgC,iBAAA;CvBmmD/B;AuBlmDD;EAAuC,iBAAA;CvBqmDtC;AuBpmDD;EAAwC,iBAAA;CvBumDvC;AuBtmDD;EAAmC,iBAAA;CvBymDlC;AuBxmDD;EAA0C,iBAAA;CvB2mDzC;AuB1mDD;EAAqC,iBAAA;CvB6mDpC;AuB5mDD;EAAkC,iBAAA;CvB+mDjC;AuB9mDD;EAA+B,iBAAA;CvBinD9B;AuBhnDD;EAAqC,iBAAA;CvBmnDpC;AuBlnDD;EAA4C,iBAAA;CvBqnD3C;AuBpnDD;EAAkC,iBAAA;CvBunDjC;AuBtnDD;EAAyC,iBAAA;CvBynDxC;AuBxnDD;EAA2C,iBAAA;CvB2nD1C;AuB1nDD;EAAyC,iBAAA;CvB6nDxC;AuB5nDD;EAA2C,iBAAA;CvB+nD1C;AuB9nDD;EAA4C,iBAAA;CvBioD3C;AuBhoDD;EAAiC,iBAAA;CvBmoDhC;AuBloDD;EAAmC,iBAAA;CvBqoDlC;AuBpoDD;EAAmC,iBAAA;CvBuoDlC;AuBtoDD;EAAiC,iBAAA;CvByoDhC;AuBxoDD;EAAoC,iBAAA;CvB2oDnC;AuB1oDD;EAAiC,iBAAA;CvB6oDhC;AuB5oDD;EAAsC,iBAAA;CvB+oDrC;AuB9oDD;EAAkC,iBAAA;CvBipDjC;AuBhpDD;EAAkC,iBAAA;CvBmpDjC;AuBlpDD;EAAgC,iBAAA;CvBqpD/B;AuBppDD;;EACoC,iBAAA;CvBupDnC;AuBtpDD;EAAiC,iBAAA;CvBypDhC;AuBxpDD;EAAkC,iBAAA;CvB2pDjC;AuB1pDD;EAAmC,iBAAA;CvB6pDlC;AuB5pDD;EAA+B,iBAAA;CvB+pD9B;AuB9pDD;EAA8B,iBAAA;CvBiqD7B;AuBhqDD;EAAiC,iBAAA;CvBmqDhC;AuBlqDD;EAAkC,iBAAA;CvBqqDjC;AuBpqDD;EAAqC,iBAAA;CvBuqDpC;AuBtqDD;EAA0C,iBAAA;CvByqDzC;AuBxqDD;EAAgD,iBAAA;CvB2qD/C;AuB1qDD;EAA+C,iBAAA;CvB6qD9C;AuB5qDD;;EAC+C,iBAAA;CvB+qD9C;AuB9qDD;EAAwC,iBAAA;CvBirDvC;AuBhrDD;EAAsC,iBAAA;CvBmrDrC;AuBlrDD;EAAwC,iBAAA;CvBqrDvC;AuBprDD;;EAC+B,iBAAA;CvBurD9B;AuBtrDD;EAAyC,iBAAA;CvByrDxC;AuBxrDD;EAAyC,iBAAA;CvB2rDxC;AuB1rDD;EAAiC,iBAAA;CvB6rDhC;AuB5rDD;EAA2C,iBAAA;CvB+rD1C;AuB9rDD;EAAqC,iBAAA;CvBisDpC;AuBhsDD;EAAkC,iBAAA;CvBmsDjC;AuBlsDD;;;EAEsC,iBAAA;CvBqsDrC;AuBpsDD;;EAC0C,iBAAA;CvBusDzC;AuBtsDD;EAAiC,iBAAA;CvBysDhC;AuBxsDD;EAAkC,iBAAA;CvB2sDjC;AuB1sDD;EAAkC,iBAAA;CvB6sDjC;AuB5sDD;EAAyC,iBAAA;CvB+sDxC;AuB9sDD;EAA8C,iBAAA;CvBitD7C;AuBhtDD;EAAuC,iBAAA;CvBmtDtC;AuBltDD;EAAqC,iBAAA;CvBqtDpC;AuBptDD;EAAgC,iBAAA;CvButD/B;AuBttDD;EAAsC,iBAAA;CvBytDrC;AuBxtDD;EAA0C,iBAAA;CvB2tDzC;AuB1tDD;EAAkC,iBAAA;CvB6tDjC;AuB5tDD;EAAkC,iBAAA;CvB+tDjC;AuB9tDD;EAAoC,iBAAA;CvBiuDnC;AuBhuDD;EAA+B,iBAAA;CvBmuD9B;AuBluDD;EAAoC,iBAAA;CvBquDnC;AuBpuDD;EAAiC,iBAAA;CvBuuDhC;AuBtuDD;EAA+B,iBAAA;CvByuD9B;AuBxuDD;EAAiC,iBAAA;CvB2uDhC;AuB1uDD;EAAgC,iBAAA;CvB6uD/B;AuB5uDD;EAAiC,iBAAA;CvB+uDhC;AuB9uDD;EAAmC,iBAAA;CvBivDlC;AuBhvDD;EAA0C,iBAAA;CvBmvDzC;AuBlvDD;EAAiC,iBAAA;CvBqvDhC;AuBpvDD;EAAwC,iBAAA;CvBuvDvC;AuBtvDD;EAAmC,iBAAA;CvByvDlC;AuBxvDD;;EAC+B,iBAAA;CvB2vD9B;AuB1vDD;;EACgC,iBAAA;CvB6vD/B;AuB5vDD;EAAgC,iBAAA;CvB+vD/B;AuB9vDD;EAAmC,iBAAA;CvBiwDlC;AuBhwDD;EAAsC,iBAAA;CvBmwDrC;AuBlwDD;EAAsC,iBAAA;CvBqwDrC;AuBpwDD;EAAoC,iBAAA;CvBuwDnC;AuBtwDD;EAAsC,iBAAA;CvBywDrC;AuBxwDD;EAAuC,iBAAA;CvB2wDtC;AuB1wDD;EAAwC,iBAAA;CvB6wDvC;AuB5wDD;EAA6C,iBAAA;CvB+wD5C;AuB9wDD;;;EAEwC,iBAAA;CvBixDvC;AuBhxDD;;EAC0C,iBAAA;CvBmxDzC;AuBlxDD;;EACwC,iBAAA;CvBqxDvC;AuBpxDD;;EACwC,iBAAA;CvBuxDvC;AuBtxDD;EAAuC,iBAAA;CvByxDtC;AuBxxDD;EAAgC,iBAAA;CvB2xD/B;AuB1xDD;EAAmC,iBAAA;CvB6xDlC;AuB5xDD;EAAoC,iBAAA;CvB+xDnC;AuB9xDD;;;;;EAIqC,iBAAA;CvBiyDpC;AuBhyDD;EAA0C,iBAAA;CvBmyDzC;AuBlyDD;;EACiC,iBAAA;CvBqyDhC;AuBpyDD;;EACkC,iBAAA;CvBuyDjC;AuBtyDD;EAAsC,iBAAA;CvByyDrC;AuBxyDD;EAA+B,iBAAA;CvB2yD9B;AuB1yDD;EAAuC,iBAAA;CvB6yDtC;AuB5yDD;EAAyC,iBAAA;CvB+yDxC;AuB9yDD;EAA8B,iBAAA;CvBizD7B;AuBhzDD;;EACkC,iBAAA;CvBmzDjC;AuBlzDD;;EACuC,iBAAA;CvBqzDtC;AuBpzDD;;EACyC,iBAAA;CvBuzDxC;AuBtzDD;EAAmC,iBAAA;CvByzDlC;AuBxzDD;;EACuC,iBAAA;CvB2zDtC;AuB1zDD;EAAkC,iBAAA;CvB6zDjC;AuB5zDD;EAAqC,iBAAA;CvB+zDpC;AuB9zDD;EAAmC,iBAAA;CvBi0DlC;AuBh0DD;EAAqC,iBAAA;CvBm0DpC;AuBl0DD;EAA4C,iBAAA;CvBq0D3C;AuBp0DD;EAAgC,iBAAA;CvBu0D/B;AuBt0DD;;EACoC,iBAAA;CvBy0DnC;AuBx0DD;EAA+B,iBAAA;CvB20D9B;AuB10DD;EAAsC,iBAAA;CvB60DrC;AuB50DD;EAAgC,iBAAA;CvB+0D/B;AuB90DD;EAAsC,iBAAA;CvBi1DrC;AuBh1DD;EAAkC,iBAAA;CvBm1DjC;AuBl1DD;EAAgC,iBAAA;CvBq1D/B;AuBp1DD;EAAuC,iBAAA;CvBu1DtC;AuBt1DD;EAAgC,iBAAA;CvBy1D/B;AuBx1DD;EAAsC,iBAAA;CvB21DrC;AuB11DD;EAAkC,iBAAA;CvB61DjC;AuB51DD;EAAyC,iBAAA;CvB+1DxC;AuB91DD;EAAmC,iBAAA;CvBi2DlC;AuBh2DD;EAAyC,iBAAA;CvBm2DxC;AuBl2DD;EAAuC,iBAAA;CvBq2DtC;AuBp2DD;EAAmC,iBAAA;CvBu2DlC;AuBt2DD;EAAqC,iBAAA;CvBy2DpC;AuBx2DD;EAAqC,iBAAA;CvB22DpC;AuB12DD;EAAsC,iBAAA;CvB62DrC;AuB52DD;EAAwC,iBAAA;CvB+2DvC;AuB92DD;EAAiC,iBAAA;CvBi3DhC;AuBh3DD;EAAqC,iBAAA;CvBm3DpC;AuBl3DD;EAA8B,iBAAA;CvBq3D7B;AuBp3DD;EAAsC,iBAAA;CvBu3DrC;AuBt3DD;EAAuC,iBAAA;CvBy3DtC;AuBx3DD;EAAyC,iBAAA;CvB23DxC;AuB13DD;EAAsC,iBAAA;CvB63DrC;AuB53DD;EAAqC,iBAAA;CvB+3DpC;AuB93DD;EAAsC,iBAAA;CvBi4DrC;AuBh4DD;EAAkC,iBAAA;CvBm4DjC;AuBl4DD;EAAyC,iBAAA;CvBq4DxC;AuBp4DD;EAAsC,iBAAA;CvBu4DrC;AuBt4DD;EAAqC,iBAAA;CvBy4DpC;AuBx4DD;EAAmC,iBAAA;CvB24DlC;AuB14DD;EAA+B,iBAAA;CvB64D9B;AuB54DD;EAAmC,iBAAA;CvB+4DlC;AuB94DD;EAAqC,iBAAA;CvBi5DpC;AuBh5DD;EAA8B,iBAAA;CvBm5D7B;AuBl5DD;;;EAE+B,iBAAA;CvBq5D9B;AuBp5DD;EAAoC,iBAAA;CvBu5DnC;AuBt5DD;EAAsC,iBAAA;CvBy5DrC;AuBx5DD;EAA0C,iBAAA;CvB25DzC;AuB15DD;EAAoC,iBAAA;CvB65DnC;AuB55DD;EAAoC,iBAAA;CvB+5DnC;AuB95DD;EAAmC,iBAAA;CvBi6DlC;AuBh6DD;EAAkC,iBAAA;CvBm6DjC;AuBl6DD;EAAwC,iBAAA;CvBq6DvC;AuBp6DD;EAAuC,iBAAA;CvBu6DtC;AuBt6DD;EAAoC,iBAAA;CvBy6DnC;AuBx6DD;EAAqC,iBAAA;CvB26DpC;AuB16DD;EAA2C,iBAAA;CvB66D1C;AuB56DD;EAAmC,iBAAA;CvB+6DlC;AuB96DD;EAAgC,iBAAA;CvBi7D/B;AuBh7DD;EAAuC,iBAAA;CvBm7DtC;AuBl7DD;EAAsC,iBAAA;CvBq7DrC;AuBp7DD;EAAuC,iBAAA;CvBu7DtC;AuBt7DD;EAAqC,iBAAA;CvBy7DpC;AuBx7DD;EAAiC,iBAAA;CvB27DhC;AuB17DD;EAAgC,iBAAA;CvB67D/B;AuB57DD;EAAmC,iBAAA;CvB+7DlC;AuB97DD;EAAuC,iBAAA;CvBi8DtC;AuBh8DD;EAA2C,iBAAA;CvBm8D1C;AuBl8DD;EAAwC,iBAAA;CvBq8DvC;AuBp8DD;EAAuC,iBAAA;CvBu8DtC;AuBt8DD;EAAsC,iBAAA;CvBy8DrC;AuBx8DD;EAAuC,iBAAA;CvB28DtC;AuB18DD;EAAyC,iBAAA;CvB68DxC;AuB58DD;EAAyC,iBAAA;CvB+8DxC;AuB98DD;EAAkC,iBAAA;CvBi9DjC;AuBh9DD;EAA6C,iBAAA;CvBm9D5C;AuBl9DD;EAAuC,iBAAA;CvBq9DtC;AuBp9DD;EAAoC,iBAAA;CvBu9DnC;AuBt9DD;EAAkC,iBAAA;CvBy9DjC;AuBx9DD;EAAqC,iBAAA;CvB29DpC;AuB19DD;EAAsC,iBAAA;CvB69DrC;AuB59DD;;EAC+B,iBAAA;CvB+9D9B;AuB99DD;EAAmC,iBAAA;CvBi+DlC;AuBh+DD;EAAiC,iBAAA;CvBm+DhC;AuBl+DD;EAAkC,iBAAA;CvBq+DjC;AuBp+DD;EAAkC,iBAAA;CvBu+DjC","file":"Lib.css","sourcesContent":[".layout-editor * {\n  -webkit-box-sizing: border-box;\n  -moz-box-sizing: border-box;\n  box-sizing: border-box;\n}\n.layout-editor *:before,\n.layout-editor *:after {\n  -webkit-box-sizing: border-box;\n  -moz-box-sizing: border-box;\n  box-sizing: border-box;\n}\n.layout-editor html {\n  font-size: 10px;\n  -webkit-tap-highlight-color: rgba(0, 0, 0, 0);\n}\n.layout-editor body {\n  font-family: \"Helvetica Neue\", Helvetica, Arial, sans-serif;\n  font-size: 14px;\n  line-height: 1.42857143;\n  color: #333333;\n  background-color: #fff;\n}\n.layout-editor input,\n.layout-editor button,\n.layout-editor select,\n.layout-editor textarea {\n  font-family: inherit;\n  font-size: inherit;\n  line-height: inherit;\n}\n.layout-editor a {\n  color: #337ab7;\n  text-decoration: none;\n}\n.layout-editor a:hover,\n.layout-editor a:focus {\n  color: #23527c;\n  text-decoration: underline;\n}\n.layout-editor a:focus {\n  outline: thin dotted;\n  outline: 5px auto -webkit-focus-ring-color;\n  outline-offset: -2px;\n}\n.layout-editor figure {\n  margin: 0;\n}\n.layout-editor img {\n  vertical-align: middle;\n}\n.layout-editor .img-responsive {\n  display: block;\n  max-width: 100%;\n  height: auto;\n}\n.layout-editor .img-rounded {\n  border-radius: 6px;\n}\n.layout-editor .img-thumbnail {\n  padding: 4px;\n  line-height: 1.42857143;\n  background-color: #fff;\n  border: 1px solid #ddd;\n  border-radius: 4px;\n  -webkit-transition: all 0.2s ease-in-out;\n  -o-transition: all 0.2s ease-in-out;\n  transition: all 0.2s ease-in-out;\n  display: inline-block;\n  max-width: 100%;\n  height: auto;\n}\n.layout-editor .img-circle {\n  border-radius: 50%;\n}\n.layout-editor hr {\n  margin-top: 20px;\n  margin-bottom: 20px;\n  border: 0;\n  border-top: 1px solid #eeeeee;\n}\n.layout-editor .sr-only {\n  position: absolute;\n  width: 1px;\n  height: 1px;\n  margin: -1px;\n  padding: 0;\n  overflow: hidden;\n  clip: rect(0, 0, 0, 0);\n  border: 0;\n}\n.layout-editor .sr-only-focusable:active,\n.layout-editor .sr-only-focusable:focus {\n  position: static;\n  width: auto;\n  height: auto;\n  margin: 0;\n  overflow: visible;\n  clip: auto;\n}\n.layout-editor .container {\n  margin-right: auto;\n  margin-left: auto;\n  padding-left: 15px;\n  padding-right: 15px;\n}\n@media (min-width: 768px) {\n  .layout-editor .container {\n    width: 750px;\n  }\n}\n@media (min-width: 992px) {\n  .layout-editor .container {\n    width: 970px;\n  }\n}\n@media (min-width: 1200px) {\n  .layout-editor .container {\n    width: 1170px;\n  }\n}\n.layout-editor .container-fluid {\n  margin-right: auto;\n  margin-left: auto;\n  padding-left: 15px;\n  padding-right: 15px;\n}\n.layout-editor .row {\n  margin-left: -15px;\n  margin-right: -15px;\n}\n.layout-editor .col-xs-1, .col-sm-1, .col-md-1, .col-lg-1, .col-xs-2, .col-sm-2, .col-md-2, .col-lg-2, .col-xs-3, .col-sm-3, .col-md-3, .col-lg-3, .col-xs-4, .col-sm-4, .col-md-4, .col-lg-4, .col-xs-5, .col-sm-5, .col-md-5, .col-lg-5, .col-xs-6, .col-sm-6, .col-md-6, .col-lg-6, .col-xs-7, .col-sm-7, .col-md-7, .col-lg-7, .col-xs-8, .col-sm-8, .col-md-8, .col-lg-8, .col-xs-9, .col-sm-9, .col-md-9, .col-lg-9, .col-xs-10, .col-sm-10, .col-md-10, .col-lg-10, .col-xs-11, .col-sm-11, .col-md-11, .col-lg-11, .col-xs-12, .col-sm-12, .col-md-12, .col-lg-12 {\n  position: relative;\n  min-height: 1px;\n  padding-left: 15px;\n  padding-right: 15px;\n}\n.layout-editor .col-xs-1, .col-xs-2, .col-xs-3, .col-xs-4, .col-xs-5, .col-xs-6, .col-xs-7, .col-xs-8, .col-xs-9, .col-xs-10, .col-xs-11, .col-xs-12 {\n  float: left;\n}\n.layout-editor .col-xs-12 {\n  width: 100%;\n}\n.layout-editor .col-xs-11 {\n  width: 91.66666667%;\n}\n.layout-editor .col-xs-10 {\n  width: 83.33333333%;\n}\n.layout-editor .col-xs-9 {\n  width: 75%;\n}\n.layout-editor .col-xs-8 {\n  width: 66.66666667%;\n}\n.layout-editor .col-xs-7 {\n  width: 58.33333333%;\n}\n.layout-editor .col-xs-6 {\n  width: 50%;\n}\n.layout-editor .col-xs-5 {\n  width: 41.66666667%;\n}\n.layout-editor .col-xs-4 {\n  width: 33.33333333%;\n}\n.layout-editor .col-xs-3 {\n  width: 25%;\n}\n.layout-editor .col-xs-2 {\n  width: 16.66666667%;\n}\n.layout-editor .col-xs-1 {\n  width: 8.33333333%;\n}\n.layout-editor .col-xs-pull-12 {\n  right: 100%;\n}\n.layout-editor .col-xs-pull-11 {\n  right: 91.66666667%;\n}\n.layout-editor .col-xs-pull-10 {\n  right: 83.33333333%;\n}\n.layout-editor .col-xs-pull-9 {\n  right: 75%;\n}\n.layout-editor .col-xs-pull-8 {\n  right: 66.66666667%;\n}\n.layout-editor .col-xs-pull-7 {\n  right: 58.33333333%;\n}\n.layout-editor .col-xs-pull-6 {\n  right: 50%;\n}\n.layout-editor .col-xs-pull-5 {\n  right: 41.66666667%;\n}\n.layout-editor .col-xs-pull-4 {\n  right: 33.33333333%;\n}\n.layout-editor .col-xs-pull-3 {\n  right: 25%;\n}\n.layout-editor .col-xs-pull-2 {\n  right: 16.66666667%;\n}\n.layout-editor .col-xs-pull-1 {\n  right: 8.33333333%;\n}\n.layout-editor .col-xs-pull-0 {\n  right: auto;\n}\n.layout-editor .col-xs-push-12 {\n  left: 100%;\n}\n.layout-editor .col-xs-push-11 {\n  left: 91.66666667%;\n}\n.layout-editor .col-xs-push-10 {\n  left: 83.33333333%;\n}\n.layout-editor .col-xs-push-9 {\n  left: 75%;\n}\n.layout-editor .col-xs-push-8 {\n  left: 66.66666667%;\n}\n.layout-editor .col-xs-push-7 {\n  left: 58.33333333%;\n}\n.layout-editor .col-xs-push-6 {\n  left: 50%;\n}\n.layout-editor .col-xs-push-5 {\n  left: 41.66666667%;\n}\n.layout-editor .col-xs-push-4 {\n  left: 33.33333333%;\n}\n.layout-editor .col-xs-push-3 {\n  left: 25%;\n}\n.layout-editor .col-xs-push-2 {\n  left: 16.66666667%;\n}\n.layout-editor .col-xs-push-1 {\n  left: 8.33333333%;\n}\n.layout-editor .col-xs-push-0 {\n  left: auto;\n}\n.layout-editor .col-xs-offset-12 {\n  margin-left: 100%;\n}\n.layout-editor .col-xs-offset-11 {\n  margin-left: 91.66666667%;\n}\n.layout-editor .col-xs-offset-10 {\n  margin-left: 83.33333333%;\n}\n.layout-editor .col-xs-offset-9 {\n  margin-left: 75%;\n}\n.layout-editor .col-xs-offset-8 {\n  margin-left: 66.66666667%;\n}\n.layout-editor .col-xs-offset-7 {\n  margin-left: 58.33333333%;\n}\n.layout-editor .col-xs-offset-6 {\n  margin-left: 50%;\n}\n.layout-editor .col-xs-offset-5 {\n  margin-left: 41.66666667%;\n}\n.layout-editor .col-xs-offset-4 {\n  margin-left: 33.33333333%;\n}\n.layout-editor .col-xs-offset-3 {\n  margin-left: 25%;\n}\n.layout-editor .col-xs-offset-2 {\n  margin-left: 16.66666667%;\n}\n.layout-editor .col-xs-offset-1 {\n  margin-left: 8.33333333%;\n}\n.layout-editor .col-xs-offset-0 {\n  margin-left: 0%;\n}\n@media (min-width: 768px) {\n  .layout-editor .col-sm-1, .col-sm-2, .col-sm-3, .col-sm-4, .col-sm-5, .col-sm-6, .col-sm-7, .col-sm-8, .col-sm-9, .col-sm-10, .col-sm-11, .col-sm-12 {\n    float: left;\n  }\n  .layout-editor .col-sm-12 {\n    width: 100%;\n  }\n  .layout-editor .col-sm-11 {\n    width: 91.66666667%;\n  }\n  .layout-editor .col-sm-10 {\n    width: 83.33333333%;\n  }\n  .layout-editor .col-sm-9 {\n    width: 75%;\n  }\n  .layout-editor .col-sm-8 {\n    width: 66.66666667%;\n  }\n  .layout-editor .col-sm-7 {\n    width: 58.33333333%;\n  }\n  .layout-editor .col-sm-6 {\n    width: 50%;\n  }\n  .layout-editor .col-sm-5 {\n    width: 41.66666667%;\n  }\n  .layout-editor .col-sm-4 {\n    width: 33.33333333%;\n  }\n  .layout-editor .col-sm-3 {\n    width: 25%;\n  }\n  .layout-editor .col-sm-2 {\n    width: 16.66666667%;\n  }\n  .layout-editor .col-sm-1 {\n    width: 8.33333333%;\n  }\n  .layout-editor .col-sm-pull-12 {\n    right: 100%;\n  }\n  .layout-editor .col-sm-pull-11 {\n    right: 91.66666667%;\n  }\n  .layout-editor .col-sm-pull-10 {\n    right: 83.33333333%;\n  }\n  .layout-editor .col-sm-pull-9 {\n    right: 75%;\n  }\n  .layout-editor .col-sm-pull-8 {\n    right: 66.66666667%;\n  }\n  .layout-editor .col-sm-pull-7 {\n    right: 58.33333333%;\n  }\n  .layout-editor .col-sm-pull-6 {\n    right: 50%;\n  }\n  .layout-editor .col-sm-pull-5 {\n    right: 41.66666667%;\n  }\n  .layout-editor .col-sm-pull-4 {\n    right: 33.33333333%;\n  }\n  .layout-editor .col-sm-pull-3 {\n    right: 25%;\n  }\n  .layout-editor .col-sm-pull-2 {\n    right: 16.66666667%;\n  }\n  .layout-editor .col-sm-pull-1 {\n    right: 8.33333333%;\n  }\n  .layout-editor .col-sm-pull-0 {\n    right: auto;\n  }\n  .layout-editor .col-sm-push-12 {\n    left: 100%;\n  }\n  .layout-editor .col-sm-push-11 {\n    left: 91.66666667%;\n  }\n  .layout-editor .col-sm-push-10 {\n    left: 83.33333333%;\n  }\n  .layout-editor .col-sm-push-9 {\n    left: 75%;\n  }\n  .layout-editor .col-sm-push-8 {\n    left: 66.66666667%;\n  }\n  .layout-editor .col-sm-push-7 {\n    left: 58.33333333%;\n  }\n  .layout-editor .col-sm-push-6 {\n    left: 50%;\n  }\n  .layout-editor .col-sm-push-5 {\n    left: 41.66666667%;\n  }\n  .layout-editor .col-sm-push-4 {\n    left: 33.33333333%;\n  }\n  .layout-editor .col-sm-push-3 {\n    left: 25%;\n  }\n  .layout-editor .col-sm-push-2 {\n    left: 16.66666667%;\n  }\n  .layout-editor .col-sm-push-1 {\n    left: 8.33333333%;\n  }\n  .layout-editor .col-sm-push-0 {\n    left: auto;\n  }\n  .layout-editor .col-sm-offset-12 {\n    margin-left: 100%;\n  }\n  .layout-editor .col-sm-offset-11 {\n    margin-left: 91.66666667%;\n  }\n  .layout-editor .col-sm-offset-10 {\n    margin-left: 83.33333333%;\n  }\n  .layout-editor .col-sm-offset-9 {\n    margin-left: 75%;\n  }\n  .layout-editor .col-sm-offset-8 {\n    margin-left: 66.66666667%;\n  }\n  .layout-editor .col-sm-offset-7 {\n    margin-left: 58.33333333%;\n  }\n  .layout-editor .col-sm-offset-6 {\n    margin-left: 50%;\n  }\n  .layout-editor .col-sm-offset-5 {\n    margin-left: 41.66666667%;\n  }\n  .layout-editor .col-sm-offset-4 {\n    margin-left: 33.33333333%;\n  }\n  .layout-editor .col-sm-offset-3 {\n    margin-left: 25%;\n  }\n  .layout-editor .col-sm-offset-2 {\n    margin-left: 16.66666667%;\n  }\n  .layout-editor .col-sm-offset-1 {\n    margin-left: 8.33333333%;\n  }\n  .layout-editor .col-sm-offset-0 {\n    margin-left: 0%;\n  }\n}\n@media (min-width: 992px) {\n  .layout-editor .col-md-1, .col-md-2, .col-md-3, .col-md-4, .col-md-5, .col-md-6, .col-md-7, .col-md-8, .col-md-9, .col-md-10, .col-md-11, .col-md-12 {\n    float: left;\n  }\n  .layout-editor .col-md-12 {\n    width: 100%;\n  }\n  .layout-editor .col-md-11 {\n    width: 91.66666667%;\n  }\n  .layout-editor .col-md-10 {\n    width: 83.33333333%;\n  }\n  .layout-editor .col-md-9 {\n    width: 75%;\n  }\n  .layout-editor .col-md-8 {\n    width: 66.66666667%;\n  }\n  .layout-editor .col-md-7 {\n    width: 58.33333333%;\n  }\n  .layout-editor .col-md-6 {\n    width: 50%;\n  }\n  .layout-editor .col-md-5 {\n    width: 41.66666667%;\n  }\n  .layout-editor .col-md-4 {\n    width: 33.33333333%;\n  }\n  .layout-editor .col-md-3 {\n    width: 25%;\n  }\n  .layout-editor .col-md-2 {\n    width: 16.66666667%;\n  }\n  .layout-editor .col-md-1 {\n    width: 8.33333333%;\n  }\n  .layout-editor .col-md-pull-12 {\n    right: 100%;\n  }\n  .layout-editor .col-md-pull-11 {\n    right: 91.66666667%;\n  }\n  .layout-editor .col-md-pull-10 {\n    right: 83.33333333%;\n  }\n  .layout-editor .col-md-pull-9 {\n    right: 75%;\n  }\n  .layout-editor .col-md-pull-8 {\n    right: 66.66666667%;\n  }\n  .layout-editor .col-md-pull-7 {\n    right: 58.33333333%;\n  }\n  .layout-editor .col-md-pull-6 {\n    right: 50%;\n  }\n  .layout-editor .col-md-pull-5 {\n    right: 41.66666667%;\n  }\n  .layout-editor .col-md-pull-4 {\n    right: 33.33333333%;\n  }\n  .layout-editor .col-md-pull-3 {\n    right: 25%;\n  }\n  .layout-editor .col-md-pull-2 {\n    right: 16.66666667%;\n  }\n  .layout-editor .col-md-pull-1 {\n    right: 8.33333333%;\n  }\n  .layout-editor .col-md-pull-0 {\n    right: auto;\n  }\n  .layout-editor .col-md-push-12 {\n    left: 100%;\n  }\n  .layout-editor .col-md-push-11 {\n    left: 91.66666667%;\n  }\n  .layout-editor .col-md-push-10 {\n    left: 83.33333333%;\n  }\n  .layout-editor .col-md-push-9 {\n    left: 75%;\n  }\n  .layout-editor .col-md-push-8 {\n    left: 66.66666667%;\n  }\n  .layout-editor .col-md-push-7 {\n    left: 58.33333333%;\n  }\n  .layout-editor .col-md-push-6 {\n    left: 50%;\n  }\n  .layout-editor .col-md-push-5 {\n    left: 41.66666667%;\n  }\n  .layout-editor .col-md-push-4 {\n    left: 33.33333333%;\n  }\n  .layout-editor .col-md-push-3 {\n    left: 25%;\n  }\n  .layout-editor .col-md-push-2 {\n    left: 16.66666667%;\n  }\n  .layout-editor .col-md-push-1 {\n    left: 8.33333333%;\n  }\n  .layout-editor .col-md-push-0 {\n    left: auto;\n  }\n  .layout-editor .col-md-offset-12 {\n    margin-left: 100%;\n  }\n  .layout-editor .col-md-offset-11 {\n    margin-left: 91.66666667%;\n  }\n  .layout-editor .col-md-offset-10 {\n    margin-left: 83.33333333%;\n  }\n  .layout-editor .col-md-offset-9 {\n    margin-left: 75%;\n  }\n  .layout-editor .col-md-offset-8 {\n    margin-left: 66.66666667%;\n  }\n  .layout-editor .col-md-offset-7 {\n    margin-left: 58.33333333%;\n  }\n  .layout-editor .col-md-offset-6 {\n    margin-left: 50%;\n  }\n  .layout-editor .col-md-offset-5 {\n    margin-left: 41.66666667%;\n  }\n  .layout-editor .col-md-offset-4 {\n    margin-left: 33.33333333%;\n  }\n  .layout-editor .col-md-offset-3 {\n    margin-left: 25%;\n  }\n  .layout-editor .col-md-offset-2 {\n    margin-left: 16.66666667%;\n  }\n  .layout-editor .col-md-offset-1 {\n    margin-left: 8.33333333%;\n  }\n  .layout-editor .col-md-offset-0 {\n    margin-left: 0%;\n  }\n}\n@media (min-width: 1200px) {\n  .layout-editor .col-lg-1, .col-lg-2, .col-lg-3, .col-lg-4, .col-lg-5, .col-lg-6, .col-lg-7, .col-lg-8, .col-lg-9, .col-lg-10, .col-lg-11, .col-lg-12 {\n    float: left;\n  }\n  .layout-editor .col-lg-12 {\n    width: 100%;\n  }\n  .layout-editor .col-lg-11 {\n    width: 91.66666667%;\n  }\n  .layout-editor .col-lg-10 {\n    width: 83.33333333%;\n  }\n  .layout-editor .col-lg-9 {\n    width: 75%;\n  }\n  .layout-editor .col-lg-8 {\n    width: 66.66666667%;\n  }\n  .layout-editor .col-lg-7 {\n    width: 58.33333333%;\n  }\n  .layout-editor .col-lg-6 {\n    width: 50%;\n  }\n  .layout-editor .col-lg-5 {\n    width: 41.66666667%;\n  }\n  .layout-editor .col-lg-4 {\n    width: 33.33333333%;\n  }\n  .layout-editor .col-lg-3 {\n    width: 25%;\n  }\n  .layout-editor .col-lg-2 {\n    width: 16.66666667%;\n  }\n  .layout-editor .col-lg-1 {\n    width: 8.33333333%;\n  }\n  .layout-editor .col-lg-pull-12 {\n    right: 100%;\n  }\n  .layout-editor .col-lg-pull-11 {\n    right: 91.66666667%;\n  }\n  .layout-editor .col-lg-pull-10 {\n    right: 83.33333333%;\n  }\n  .layout-editor .col-lg-pull-9 {\n    right: 75%;\n  }\n  .layout-editor .col-lg-pull-8 {\n    right: 66.66666667%;\n  }\n  .layout-editor .col-lg-pull-7 {\n    right: 58.33333333%;\n  }\n  .layout-editor .col-lg-pull-6 {\n    right: 50%;\n  }\n  .layout-editor .col-lg-pull-5 {\n    right: 41.66666667%;\n  }\n  .layout-editor .col-lg-pull-4 {\n    right: 33.33333333%;\n  }\n  .layout-editor .col-lg-pull-3 {\n    right: 25%;\n  }\n  .layout-editor .col-lg-pull-2 {\n    right: 16.66666667%;\n  }\n  .layout-editor .col-lg-pull-1 {\n    right: 8.33333333%;\n  }\n  .layout-editor .col-lg-pull-0 {\n    right: auto;\n  }\n  .layout-editor .col-lg-push-12 {\n    left: 100%;\n  }\n  .layout-editor .col-lg-push-11 {\n    left: 91.66666667%;\n  }\n  .layout-editor .col-lg-push-10 {\n    left: 83.33333333%;\n  }\n  .layout-editor .col-lg-push-9 {\n    left: 75%;\n  }\n  .layout-editor .col-lg-push-8 {\n    left: 66.66666667%;\n  }\n  .layout-editor .col-lg-push-7 {\n    left: 58.33333333%;\n  }\n  .layout-editor .col-lg-push-6 {\n    left: 50%;\n  }\n  .layout-editor .col-lg-push-5 {\n    left: 41.66666667%;\n  }\n  .layout-editor .col-lg-push-4 {\n    left: 33.33333333%;\n  }\n  .layout-editor .col-lg-push-3 {\n    left: 25%;\n  }\n  .layout-editor .col-lg-push-2 {\n    left: 16.66666667%;\n  }\n  .layout-editor .col-lg-push-1 {\n    left: 8.33333333%;\n  }\n  .layout-editor .col-lg-push-0 {\n    left: auto;\n  }\n  .layout-editor .col-lg-offset-12 {\n    margin-left: 100%;\n  }\n  .layout-editor .col-lg-offset-11 {\n    margin-left: 91.66666667%;\n  }\n  .layout-editor .col-lg-offset-10 {\n    margin-left: 83.33333333%;\n  }\n  .layout-editor .col-lg-offset-9 {\n    margin-left: 75%;\n  }\n  .layout-editor .col-lg-offset-8 {\n    margin-left: 66.66666667%;\n  }\n  .layout-editor .col-lg-offset-7 {\n    margin-left: 58.33333333%;\n  }\n  .layout-editor .col-lg-offset-6 {\n    margin-left: 50%;\n  }\n  .layout-editor .col-lg-offset-5 {\n    margin-left: 41.66666667%;\n  }\n  .layout-editor .col-lg-offset-4 {\n    margin-left: 33.33333333%;\n  }\n  .layout-editor .col-lg-offset-3 {\n    margin-left: 25%;\n  }\n  .layout-editor .col-lg-offset-2 {\n    margin-left: 16.66666667%;\n  }\n  .layout-editor .col-lg-offset-1 {\n    margin-left: 8.33333333%;\n  }\n  .layout-editor .col-lg-offset-0 {\n    margin-left: 0%;\n  }\n}\n.clearfix:before,\n.clearfix:after,\n.layout-editor .container:before,\n.layout-editor .container:after,\n.layout-editor .container-fluid:before,\n.layout-editor .container-fluid:after,\n.layout-editor .row:before,\n.layout-editor .row:after {\n  content: \" \";\n  display: table;\n}\n.clearfix:after,\n.layout-editor .container:after,\n.layout-editor .container-fluid:after,\n.layout-editor .row:after {\n  clear: both;\n}\n.center-block {\n  display: block;\n  margin-left: auto;\n  margin-right: auto;\n}\n.pull-right {\n  float: right !important;\n}\n.pull-left {\n  float: left !important;\n}\n.hide {\n  display: none !important;\n}\n.show {\n  display: block !important;\n}\n.invisible {\n  visibility: hidden;\n}\n.text-hide {\n  font: 0/0 a;\n  color: transparent;\n  text-shadow: none;\n  background-color: transparent;\n  border: 0;\n}\n.hidden {\n  display: none !important;\n  visibility: hidden !important;\n}\n.affix {\n  position: fixed;\n}\n\n/*!\n *  Font Awesome 4.3.0 by @davegandy - http://fontawesome.io - @fontawesome\n *  License - http://fontawesome.io/license (Font: SIL OFL 1.1, CSS: MIT License)\n */\n/* FONT PATH\n * -------------------------- */\n@font-face {\n  font-family: 'FontAwesome';\n  src: url('Fonts/fontawesome-webfont.eot?v=4.3.0');\n  src: url('Fonts/fontawesome-webfont.eot?#iefix&v=4.3.0') format('embedded-opentype'), url('Fonts/fontawesome-webfont.woff2?v=4.3.0') format('woff2'), url('Fonts/fontawesome-webfont.woff?v=4.3.0') format('woff'), url('Fonts/fontawesome-webfont.ttf?v=4.3.0') format('truetype'), url('Fonts/fontawesome-webfont.svg?v=4.3.0#fontawesomeregular') format('svg');\n  font-weight: normal;\n  font-style: normal;\n}\n.fa {\n  display: inline-block;\n  font: normal normal normal 14px/1 FontAwesome;\n  font-size: inherit;\n  text-rendering: auto;\n  -webkit-font-smoothing: antialiased;\n  -moz-osx-font-smoothing: grayscale;\n  transform: translate(0, 0);\n}\n/* makes the font 33% larger relative to the icon container */\n.fa-lg {\n  font-size: 1.33333333em;\n  line-height: 0.75em;\n  vertical-align: -15%;\n}\n.fa-2x {\n  font-size: 2em;\n}\n.fa-3x {\n  font-size: 3em;\n}\n.fa-4x {\n  font-size: 4em;\n}\n.fa-5x {\n  font-size: 5em;\n}\n.fa-fw {\n  width: 1.28571429em;\n  text-align: center;\n}\n.fa-ul {\n  padding-left: 0;\n  margin-left: 2.14285714em;\n  list-style-type: none;\n}\n.fa-ul > li {\n  position: relative;\n}\n.fa-li {\n  position: absolute;\n  left: -2.14285714em;\n  width: 2.14285714em;\n  top: 0.14285714em;\n  text-align: center;\n}\n.fa-li.fa-lg {\n  left: -1.85714286em;\n}\n.fa-border {\n  padding: .2em .25em .15em;\n  border: solid 0.08em #eee;\n  border-radius: .1em;\n}\n.pull-right {\n  float: right;\n}\n.pull-left {\n  float: left;\n}\n.fa.pull-left {\n  margin-right: .3em;\n}\n.fa.pull-right {\n  margin-left: .3em;\n}\n.fa-spin {\n  -webkit-animation: fa-spin 2s infinite linear;\n  animation: fa-spin 2s infinite linear;\n}\n.fa-pulse {\n  -webkit-animation: fa-spin 1s infinite steps(8);\n  animation: fa-spin 1s infinite steps(8);\n}\n@-webkit-keyframes fa-spin {\n  0% {\n    -webkit-transform: rotate(0deg);\n    transform: rotate(0deg);\n  }\n  100% {\n    -webkit-transform: rotate(359deg);\n    transform: rotate(359deg);\n  }\n}\n@keyframes fa-spin {\n  0% {\n    -webkit-transform: rotate(0deg);\n    transform: rotate(0deg);\n  }\n  100% {\n    -webkit-transform: rotate(359deg);\n    transform: rotate(359deg);\n  }\n}\n.fa-rotate-90 {\n  filter: progid:DXImageTransform.Microsoft.BasicImage(rotation=1);\n  -webkit-transform: rotate(90deg);\n  -ms-transform: rotate(90deg);\n  transform: rotate(90deg);\n}\n.fa-rotate-180 {\n  filter: progid:DXImageTransform.Microsoft.BasicImage(rotation=2);\n  -webkit-transform: rotate(180deg);\n  -ms-transform: rotate(180deg);\n  transform: rotate(180deg);\n}\n.fa-rotate-270 {\n  filter: progid:DXImageTransform.Microsoft.BasicImage(rotation=3);\n  -webkit-transform: rotate(270deg);\n  -ms-transform: rotate(270deg);\n  transform: rotate(270deg);\n}\n.fa-flip-horizontal {\n  filter: progid:DXImageTransform.Microsoft.BasicImage(rotation=0, mirror=1);\n  -webkit-transform: scale(-1, 1);\n  -ms-transform: scale(-1, 1);\n  transform: scale(-1, 1);\n}\n.fa-flip-vertical {\n  filter: progid:DXImageTransform.Microsoft.BasicImage(rotation=2, mirror=1);\n  -webkit-transform: scale(1, -1);\n  -ms-transform: scale(1, -1);\n  transform: scale(1, -1);\n}\n:root .fa-rotate-90,\n:root .fa-rotate-180,\n:root .fa-rotate-270,\n:root .fa-flip-horizontal,\n:root .fa-flip-vertical {\n  filter: none;\n}\n.fa-stack {\n  position: relative;\n  display: inline-block;\n  width: 2em;\n  height: 2em;\n  line-height: 2em;\n  vertical-align: middle;\n}\n.fa-stack-1x,\n.fa-stack-2x {\n  position: absolute;\n  left: 0;\n  width: 100%;\n  text-align: center;\n}\n.fa-stack-1x {\n  line-height: inherit;\n}\n.fa-stack-2x {\n  font-size: 2em;\n}\n.fa-inverse {\n  color: #fff;\n}\n/* Font Awesome uses the Unicode Private Use Area (PUA) to ensure screen\n   readers do not read off random characters that represent icons */\n.fa-glass:before {\n  content: \"\\f000\";\n}\n.fa-music:before {\n  content: \"\\f001\";\n}\n.fa-search:before {\n  content: \"\\f002\";\n}\n.fa-envelope-o:before {\n  content: \"\\f003\";\n}\n.fa-heart:before {\n  content: \"\\f004\";\n}\n.fa-star:before {\n  content: \"\\f005\";\n}\n.fa-star-o:before {\n  content: \"\\f006\";\n}\n.fa-user:before {\n  content: \"\\f007\";\n}\n.fa-film:before {\n  content: \"\\f008\";\n}\n.fa-th-large:before {\n  content: \"\\f009\";\n}\n.fa-th:before {\n  content: \"\\f00a\";\n}\n.fa-th-list:before {\n  content: \"\\f00b\";\n}\n.fa-check:before {\n  content: \"\\f00c\";\n}\n.fa-remove:before,\n.fa-close:before,\n.fa-times:before {\n  content: \"\\f00d\";\n}\n.fa-search-plus:before {\n  content: \"\\f00e\";\n}\n.fa-search-minus:before {\n  content: \"\\f010\";\n}\n.fa-power-off:before {\n  content: \"\\f011\";\n}\n.fa-signal:before {\n  content: \"\\f012\";\n}\n.fa-gear:before,\n.fa-cog:before {\n  content: \"\\f013\";\n}\n.fa-trash-o:before {\n  content: \"\\f014\";\n}\n.fa-home:before {\n  content: \"\\f015\";\n}\n.fa-file-o:before {\n  content: \"\\f016\";\n}\n.fa-clock-o:before {\n  content: \"\\f017\";\n}\n.fa-road:before {\n  content: \"\\f018\";\n}\n.fa-download:before {\n  content: \"\\f019\";\n}\n.fa-arrow-circle-o-down:before {\n  content: \"\\f01a\";\n}\n.fa-arrow-circle-o-up:before {\n  content: \"\\f01b\";\n}\n.fa-inbox:before {\n  content: \"\\f01c\";\n}\n.fa-play-circle-o:before {\n  content: \"\\f01d\";\n}\n.fa-rotate-right:before,\n.fa-repeat:before {\n  content: \"\\f01e\";\n}\n.fa-refresh:before {\n  content: \"\\f021\";\n}\n.fa-list-alt:before {\n  content: \"\\f022\";\n}\n.fa-lock:before {\n  content: \"\\f023\";\n}\n.fa-flag:before {\n  content: \"\\f024\";\n}\n.fa-headphones:before {\n  content: \"\\f025\";\n}\n.fa-volume-off:before {\n  content: \"\\f026\";\n}\n.fa-volume-down:before {\n  content: \"\\f027\";\n}\n.fa-volume-up:before {\n  content: \"\\f028\";\n}\n.fa-qrcode:before {\n  content: \"\\f029\";\n}\n.fa-barcode:before {\n  content: \"\\f02a\";\n}\n.fa-tag:before {\n  content: \"\\f02b\";\n}\n.fa-tags:before {\n  content: \"\\f02c\";\n}\n.fa-book:before {\n  content: \"\\f02d\";\n}\n.fa-bookmark:before {\n  content: \"\\f02e\";\n}\n.fa-print:before {\n  content: \"\\f02f\";\n}\n.fa-camera:before {\n  content: \"\\f030\";\n}\n.fa-font:before {\n  content: \"\\f031\";\n}\n.fa-bold:before {\n  content: \"\\f032\";\n}\n.fa-italic:before {\n  content: \"\\f033\";\n}\n.fa-text-height:before {\n  content: \"\\f034\";\n}\n.fa-text-width:before {\n  content: \"\\f035\";\n}\n.fa-align-left:before {\n  content: \"\\f036\";\n}\n.fa-align-center:before {\n  content: \"\\f037\";\n}\n.fa-align-right:before {\n  content: \"\\f038\";\n}\n.fa-align-justify:before {\n  content: \"\\f039\";\n}\n.fa-list:before {\n  content: \"\\f03a\";\n}\n.fa-dedent:before,\n.fa-outdent:before {\n  content: \"\\f03b\";\n}\n.fa-indent:before {\n  content: \"\\f03c\";\n}\n.fa-video-camera:before {\n  content: \"\\f03d\";\n}\n.fa-photo:before,\n.fa-image:before,\n.fa-picture-o:before {\n  content: \"\\f03e\";\n}\n.fa-pencil:before {\n  content: \"\\f040\";\n}\n.fa-map-marker:before {\n  content: \"\\f041\";\n}\n.fa-adjust:before {\n  content: \"\\f042\";\n}\n.fa-tint:before {\n  content: \"\\f043\";\n}\n.fa-edit:before,\n.fa-pencil-square-o:before {\n  content: \"\\f044\";\n}\n.fa-share-square-o:before {\n  content: \"\\f045\";\n}\n.fa-check-square-o:before {\n  content: \"\\f046\";\n}\n.fa-arrows:before {\n  content: \"\\f047\";\n}\n.fa-step-backward:before {\n  content: \"\\f048\";\n}\n.fa-fast-backward:before {\n  content: \"\\f049\";\n}\n.fa-backward:before {\n  content: \"\\f04a\";\n}\n.fa-play:before {\n  content: \"\\f04b\";\n}\n.fa-pause:before {\n  content: \"\\f04c\";\n}\n.fa-stop:before {\n  content: \"\\f04d\";\n}\n.fa-forward:before {\n  content: \"\\f04e\";\n}\n.fa-fast-forward:before {\n  content: \"\\f050\";\n}\n.fa-step-forward:before {\n  content: \"\\f051\";\n}\n.fa-eject:before {\n  content: \"\\f052\";\n}\n.fa-chevron-left:before {\n  content: \"\\f053\";\n}\n.fa-chevron-right:before {\n  content: \"\\f054\";\n}\n.fa-plus-circle:before {\n  content: \"\\f055\";\n}\n.fa-minus-circle:before {\n  content: \"\\f056\";\n}\n.fa-times-circle:before {\n  content: \"\\f057\";\n}\n.fa-check-circle:before {\n  content: \"\\f058\";\n}\n.fa-question-circle:before {\n  content: \"\\f059\";\n}\n.fa-info-circle:before {\n  content: \"\\f05a\";\n}\n.fa-crosshairs:before {\n  content: \"\\f05b\";\n}\n.fa-times-circle-o:before {\n  content: \"\\f05c\";\n}\n.fa-check-circle-o:before {\n  content: \"\\f05d\";\n}\n.fa-ban:before {\n  content: \"\\f05e\";\n}\n.fa-arrow-left:before {\n  content: \"\\f060\";\n}\n.fa-arrow-right:before {\n  content: \"\\f061\";\n}\n.fa-arrow-up:before {\n  content: \"\\f062\";\n}\n.fa-arrow-down:before {\n  content: \"\\f063\";\n}\n.fa-mail-forward:before,\n.fa-share:before {\n  content: \"\\f064\";\n}\n.fa-expand:before {\n  content: \"\\f065\";\n}\n.fa-compress:before {\n  content: \"\\f066\";\n}\n.fa-plus:before {\n  content: \"\\f067\";\n}\n.fa-minus:before {\n  content: \"\\f068\";\n}\n.fa-asterisk:before {\n  content: \"\\f069\";\n}\n.fa-exclamation-circle:before {\n  content: \"\\f06a\";\n}\n.fa-gift:before {\n  content: \"\\f06b\";\n}\n.fa-leaf:before {\n  content: \"\\f06c\";\n}\n.fa-fire:before {\n  content: \"\\f06d\";\n}\n.fa-eye:before {\n  content: \"\\f06e\";\n}\n.fa-eye-slash:before {\n  content: \"\\f070\";\n}\n.fa-warning:before,\n.fa-exclamation-triangle:before {\n  content: \"\\f071\";\n}\n.fa-plane:before {\n  content: \"\\f072\";\n}\n.fa-calendar:before {\n  content: \"\\f073\";\n}\n.fa-random:before {\n  content: \"\\f074\";\n}\n.fa-comment:before {\n  content: \"\\f075\";\n}\n.fa-magnet:before {\n  content: \"\\f076\";\n}\n.fa-chevron-up:before {\n  content: \"\\f077\";\n}\n.fa-chevron-down:before {\n  content: \"\\f078\";\n}\n.fa-retweet:before {\n  content: \"\\f079\";\n}\n.fa-shopping-cart:before {\n  content: \"\\f07a\";\n}\n.fa-folder:before {\n  content: \"\\f07b\";\n}\n.fa-folder-open:before {\n  content: \"\\f07c\";\n}\n.fa-arrows-v:before {\n  content: \"\\f07d\";\n}\n.fa-arrows-h:before {\n  content: \"\\f07e\";\n}\n.fa-bar-chart-o:before,\n.fa-bar-chart:before {\n  content: \"\\f080\";\n}\n.fa-twitter-square:before {\n  content: \"\\f081\";\n}\n.fa-facebook-square:before {\n  content: \"\\f082\";\n}\n.fa-camera-retro:before {\n  content: \"\\f083\";\n}\n.fa-key:before {\n  content: \"\\f084\";\n}\n.fa-gears:before,\n.fa-cogs:before {\n  content: \"\\f085\";\n}\n.fa-comments:before {\n  content: \"\\f086\";\n}\n.fa-thumbs-o-up:before {\n  content: \"\\f087\";\n}\n.fa-thumbs-o-down:before {\n  content: \"\\f088\";\n}\n.fa-star-half:before {\n  content: \"\\f089\";\n}\n.fa-heart-o:before {\n  content: \"\\f08a\";\n}\n.fa-sign-out:before {\n  content: \"\\f08b\";\n}\n.fa-linkedin-square:before {\n  content: \"\\f08c\";\n}\n.fa-thumb-tack:before {\n  content: \"\\f08d\";\n}\n.fa-external-link:before {\n  content: \"\\f08e\";\n}\n.fa-sign-in:before {\n  content: \"\\f090\";\n}\n.fa-trophy:before {\n  content: \"\\f091\";\n}\n.fa-github-square:before {\n  content: \"\\f092\";\n}\n.fa-upload:before {\n  content: \"\\f093\";\n}\n.fa-lemon-o:before {\n  content: \"\\f094\";\n}\n.fa-phone:before {\n  content: \"\\f095\";\n}\n.fa-square-o:before {\n  content: \"\\f096\";\n}\n.fa-bookmark-o:before {\n  content: \"\\f097\";\n}\n.fa-phone-square:before {\n  content: \"\\f098\";\n}\n.fa-twitter:before {\n  content: \"\\f099\";\n}\n.fa-facebook-f:before,\n.fa-facebook:before {\n  content: \"\\f09a\";\n}\n.fa-github:before {\n  content: \"\\f09b\";\n}\n.fa-unlock:before {\n  content: \"\\f09c\";\n}\n.fa-credit-card:before {\n  content: \"\\f09d\";\n}\n.fa-rss:before {\n  content: \"\\f09e\";\n}\n.fa-hdd-o:before {\n  content: \"\\f0a0\";\n}\n.fa-bullhorn:before {\n  content: \"\\f0a1\";\n}\n.fa-bell:before {\n  content: \"\\f0f3\";\n}\n.fa-certificate:before {\n  content: \"\\f0a3\";\n}\n.fa-hand-o-right:before {\n  content: \"\\f0a4\";\n}\n.fa-hand-o-left:before {\n  content: \"\\f0a5\";\n}\n.fa-hand-o-up:before {\n  content: \"\\f0a6\";\n}\n.fa-hand-o-down:before {\n  content: \"\\f0a7\";\n}\n.fa-arrow-circle-left:before {\n  content: \"\\f0a8\";\n}\n.fa-arrow-circle-right:before {\n  content: \"\\f0a9\";\n}\n.fa-arrow-circle-up:before {\n  content: \"\\f0aa\";\n}\n.fa-arrow-circle-down:before {\n  content: \"\\f0ab\";\n}\n.fa-globe:before {\n  content: \"\\f0ac\";\n}\n.fa-wrench:before {\n  content: \"\\f0ad\";\n}\n.fa-tasks:before {\n  content: \"\\f0ae\";\n}\n.fa-filter:before {\n  content: \"\\f0b0\";\n}\n.fa-briefcase:before {\n  content: \"\\f0b1\";\n}\n.fa-arrows-alt:before {\n  content: \"\\f0b2\";\n}\n.fa-group:before,\n.fa-users:before {\n  content: \"\\f0c0\";\n}\n.fa-chain:before,\n.fa-link:before {\n  content: \"\\f0c1\";\n}\n.fa-cloud:before {\n  content: \"\\f0c2\";\n}\n.fa-flask:before {\n  content: \"\\f0c3\";\n}\n.fa-cut:before,\n.fa-scissors:before {\n  content: \"\\f0c4\";\n}\n.fa-copy:before,\n.fa-files-o:before {\n  content: \"\\f0c5\";\n}\n.fa-paperclip:before {\n  content: \"\\f0c6\";\n}\n.fa-save:before,\n.fa-floppy-o:before {\n  content: \"\\f0c7\";\n}\n.fa-square:before {\n  content: \"\\f0c8\";\n}\n.fa-navicon:before,\n.fa-reorder:before,\n.fa-bars:before {\n  content: \"\\f0c9\";\n}\n.fa-list-ul:before {\n  content: \"\\f0ca\";\n}\n.fa-list-ol:before {\n  content: \"\\f0cb\";\n}\n.fa-strikethrough:before {\n  content: \"\\f0cc\";\n}\n.fa-underline:before {\n  content: \"\\f0cd\";\n}\n.fa-table:before {\n  content: \"\\f0ce\";\n}\n.fa-magic:before {\n  content: \"\\f0d0\";\n}\n.fa-truck:before {\n  content: \"\\f0d1\";\n}\n.fa-pinterest:before {\n  content: \"\\f0d2\";\n}\n.fa-pinterest-square:before {\n  content: \"\\f0d3\";\n}\n.fa-google-plus-square:before {\n  content: \"\\f0d4\";\n}\n.fa-google-plus:before {\n  content: \"\\f0d5\";\n}\n.fa-money:before {\n  content: \"\\f0d6\";\n}\n.fa-caret-down:before {\n  content: \"\\f0d7\";\n}\n.fa-caret-up:before {\n  content: \"\\f0d8\";\n}\n.fa-caret-left:before {\n  content: \"\\f0d9\";\n}\n.fa-caret-right:before {\n  content: \"\\f0da\";\n}\n.fa-columns:before {\n  content: \"\\f0db\";\n}\n.fa-unsorted:before,\n.fa-sort:before {\n  content: \"\\f0dc\";\n}\n.fa-sort-down:before,\n.fa-sort-desc:before {\n  content: \"\\f0dd\";\n}\n.fa-sort-up:before,\n.fa-sort-asc:before {\n  content: \"\\f0de\";\n}\n.fa-envelope:before {\n  content: \"\\f0e0\";\n}\n.fa-linkedin:before {\n  content: \"\\f0e1\";\n}\n.fa-rotate-left:before,\n.fa-undo:before {\n  content: \"\\f0e2\";\n}\n.fa-legal:before,\n.fa-gavel:before {\n  content: \"\\f0e3\";\n}\n.fa-dashboard:before,\n.fa-tachometer:before {\n  content: \"\\f0e4\";\n}\n.fa-comment-o:before {\n  content: \"\\f0e5\";\n}\n.fa-comments-o:before {\n  content: \"\\f0e6\";\n}\n.fa-flash:before,\n.fa-bolt:before {\n  content: \"\\f0e7\";\n}\n.fa-sitemap:before {\n  content: \"\\f0e8\";\n}\n.fa-umbrella:before {\n  content: \"\\f0e9\";\n}\n.fa-paste:before,\n.fa-clipboard:before {\n  content: \"\\f0ea\";\n}\n.fa-lightbulb-o:before {\n  content: \"\\f0eb\";\n}\n.fa-exchange:before {\n  content: \"\\f0ec\";\n}\n.fa-cloud-download:before {\n  content: \"\\f0ed\";\n}\n.fa-cloud-upload:before {\n  content: \"\\f0ee\";\n}\n.fa-user-md:before {\n  content: \"\\f0f0\";\n}\n.fa-stethoscope:before {\n  content: \"\\f0f1\";\n}\n.fa-suitcase:before {\n  content: \"\\f0f2\";\n}\n.fa-bell-o:before {\n  content: \"\\f0a2\";\n}\n.fa-coffee:before {\n  content: \"\\f0f4\";\n}\n.fa-cutlery:before {\n  content: \"\\f0f5\";\n}\n.fa-file-text-o:before {\n  content: \"\\f0f6\";\n}\n.fa-building-o:before {\n  content: \"\\f0f7\";\n}\n.fa-hospital-o:before {\n  content: \"\\f0f8\";\n}\n.fa-ambulance:before {\n  content: \"\\f0f9\";\n}\n.fa-medkit:before {\n  content: \"\\f0fa\";\n}\n.fa-fighter-jet:before {\n  content: \"\\f0fb\";\n}\n.fa-beer:before {\n  content: \"\\f0fc\";\n}\n.fa-h-square:before {\n  content: \"\\f0fd\";\n}\n.fa-plus-square:before {\n  content: \"\\f0fe\";\n}\n.fa-angle-double-left:before {\n  content: \"\\f100\";\n}\n.fa-angle-double-right:before {\n  content: \"\\f101\";\n}\n.fa-angle-double-up:before {\n  content: \"\\f102\";\n}\n.fa-angle-double-down:before {\n  content: \"\\f103\";\n}\n.fa-angle-left:before {\n  content: \"\\f104\";\n}\n.fa-angle-right:before {\n  content: \"\\f105\";\n}\n.fa-angle-up:before {\n  content: \"\\f106\";\n}\n.fa-angle-down:before {\n  content: \"\\f107\";\n}\n.fa-desktop:before {\n  content: \"\\f108\";\n}\n.fa-laptop:before {\n  content: \"\\f109\";\n}\n.fa-tablet:before {\n  content: \"\\f10a\";\n}\n.fa-mobile-phone:before,\n.fa-mobile:before {\n  content: \"\\f10b\";\n}\n.fa-circle-o:before {\n  content: \"\\f10c\";\n}\n.fa-quote-left:before {\n  content: \"\\f10d\";\n}\n.fa-quote-right:before {\n  content: \"\\f10e\";\n}\n.fa-spinner:before {\n  content: \"\\f110\";\n}\n.fa-circle:before {\n  content: \"\\f111\";\n}\n.fa-mail-reply:before,\n.fa-reply:before {\n  content: \"\\f112\";\n}\n.fa-github-alt:before {\n  content: \"\\f113\";\n}\n.fa-folder-o:before {\n  content: \"\\f114\";\n}\n.fa-folder-open-o:before {\n  content: \"\\f115\";\n}\n.fa-smile-o:before {\n  content: \"\\f118\";\n}\n.fa-frown-o:before {\n  content: \"\\f119\";\n}\n.fa-meh-o:before {\n  content: \"\\f11a\";\n}\n.fa-gamepad:before {\n  content: \"\\f11b\";\n}\n.fa-keyboard-o:before {\n  content: \"\\f11c\";\n}\n.fa-flag-o:before {\n  content: \"\\f11d\";\n}\n.fa-flag-checkered:before {\n  content: \"\\f11e\";\n}\n.fa-terminal:before {\n  content: \"\\f120\";\n}\n.fa-code:before {\n  content: \"\\f121\";\n}\n.fa-mail-reply-all:before,\n.fa-reply-all:before {\n  content: \"\\f122\";\n}\n.fa-star-half-empty:before,\n.fa-star-half-full:before,\n.fa-star-half-o:before {\n  content: \"\\f123\";\n}\n.fa-location-arrow:before {\n  content: \"\\f124\";\n}\n.fa-crop:before {\n  content: \"\\f125\";\n}\n.fa-code-fork:before {\n  content: \"\\f126\";\n}\n.fa-unlink:before,\n.fa-chain-broken:before {\n  content: \"\\f127\";\n}\n.fa-question:before {\n  content: \"\\f128\";\n}\n.fa-info:before {\n  content: \"\\f129\";\n}\n.fa-exclamation:before {\n  content: \"\\f12a\";\n}\n.fa-superscript:before {\n  content: \"\\f12b\";\n}\n.fa-subscript:before {\n  content: \"\\f12c\";\n}\n.fa-eraser:before {\n  content: \"\\f12d\";\n}\n.fa-puzzle-piece:before {\n  content: \"\\f12e\";\n}\n.fa-microphone:before {\n  content: \"\\f130\";\n}\n.fa-microphone-slash:before {\n  content: \"\\f131\";\n}\n.fa-shield:before {\n  content: \"\\f132\";\n}\n.fa-calendar-o:before {\n  content: \"\\f133\";\n}\n.fa-fire-extinguisher:before {\n  content: \"\\f134\";\n}\n.fa-rocket:before {\n  content: \"\\f135\";\n}\n.fa-maxcdn:before {\n  content: \"\\f136\";\n}\n.fa-chevron-circle-left:before {\n  content: \"\\f137\";\n}\n.fa-chevron-circle-right:before {\n  content: \"\\f138\";\n}\n.fa-chevron-circle-up:before {\n  content: \"\\f139\";\n}\n.fa-chevron-circle-down:before {\n  content: \"\\f13a\";\n}\n.fa-html5:before {\n  content: \"\\f13b\";\n}\n.fa-css3:before {\n  content: \"\\f13c\";\n}\n.fa-anchor:before {\n  content: \"\\f13d\";\n}\n.fa-unlock-alt:before {\n  content: \"\\f13e\";\n}\n.fa-bullseye:before {\n  content: \"\\f140\";\n}\n.fa-ellipsis-h:before {\n  content: \"\\f141\";\n}\n.fa-ellipsis-v:before {\n  content: \"\\f142\";\n}\n.fa-rss-square:before {\n  content: \"\\f143\";\n}\n.fa-play-circle:before {\n  content: \"\\f144\";\n}\n.fa-ticket:before {\n  content: \"\\f145\";\n}\n.fa-minus-square:before {\n  content: \"\\f146\";\n}\n.fa-minus-square-o:before {\n  content: \"\\f147\";\n}\n.fa-level-up:before {\n  content: \"\\f148\";\n}\n.fa-level-down:before {\n  content: \"\\f149\";\n}\n.fa-check-square:before {\n  content: \"\\f14a\";\n}\n.fa-pencil-square:before {\n  content: \"\\f14b\";\n}\n.fa-external-link-square:before {\n  content: \"\\f14c\";\n}\n.fa-share-square:before {\n  content: \"\\f14d\";\n}\n.fa-compass:before {\n  content: \"\\f14e\";\n}\n.fa-toggle-down:before,\n.fa-caret-square-o-down:before {\n  content: \"\\f150\";\n}\n.fa-toggle-up:before,\n.fa-caret-square-o-up:before {\n  content: \"\\f151\";\n}\n.fa-toggle-right:before,\n.fa-caret-square-o-right:before {\n  content: \"\\f152\";\n}\n.fa-euro:before,\n.fa-eur:before {\n  content: \"\\f153\";\n}\n.fa-gbp:before {\n  content: \"\\f154\";\n}\n.fa-dollar:before,\n.fa-usd:before {\n  content: \"\\f155\";\n}\n.fa-rupee:before,\n.fa-inr:before {\n  content: \"\\f156\";\n}\n.fa-cny:before,\n.fa-rmb:before,\n.fa-yen:before,\n.fa-jpy:before {\n  content: \"\\f157\";\n}\n.fa-ruble:before,\n.fa-rouble:before,\n.fa-rub:before {\n  content: \"\\f158\";\n}\n.fa-won:before,\n.fa-krw:before {\n  content: \"\\f159\";\n}\n.fa-bitcoin:before,\n.fa-btc:before {\n  content: \"\\f15a\";\n}\n.fa-file:before {\n  content: \"\\f15b\";\n}\n.fa-file-text:before {\n  content: \"\\f15c\";\n}\n.fa-sort-alpha-asc:before {\n  content: \"\\f15d\";\n}\n.fa-sort-alpha-desc:before {\n  content: \"\\f15e\";\n}\n.fa-sort-amount-asc:before {\n  content: \"\\f160\";\n}\n.fa-sort-amount-desc:before {\n  content: \"\\f161\";\n}\n.fa-sort-numeric-asc:before {\n  content: \"\\f162\";\n}\n.fa-sort-numeric-desc:before {\n  content: \"\\f163\";\n}\n.fa-thumbs-up:before {\n  content: \"\\f164\";\n}\n.fa-thumbs-down:before {\n  content: \"\\f165\";\n}\n.fa-youtube-square:before {\n  content: \"\\f166\";\n}\n.fa-youtube:before {\n  content: \"\\f167\";\n}\n.fa-xing:before {\n  content: \"\\f168\";\n}\n.fa-xing-square:before {\n  content: \"\\f169\";\n}\n.fa-youtube-play:before {\n  content: \"\\f16a\";\n}\n.fa-dropbox:before {\n  content: \"\\f16b\";\n}\n.fa-stack-overflow:before {\n  content: \"\\f16c\";\n}\n.fa-instagram:before {\n  content: \"\\f16d\";\n}\n.fa-flickr:before {\n  content: \"\\f16e\";\n}\n.fa-adn:before {\n  content: \"\\f170\";\n}\n.fa-bitbucket:before {\n  content: \"\\f171\";\n}\n.fa-bitbucket-square:before {\n  content: \"\\f172\";\n}\n.fa-tumblr:before {\n  content: \"\\f173\";\n}\n.fa-tumblr-square:before {\n  content: \"\\f174\";\n}\n.fa-long-arrow-down:before {\n  content: \"\\f175\";\n}\n.fa-long-arrow-up:before {\n  content: \"\\f176\";\n}\n.fa-long-arrow-left:before {\n  content: \"\\f177\";\n}\n.fa-long-arrow-right:before {\n  content: \"\\f178\";\n}\n.fa-apple:before {\n  content: \"\\f179\";\n}\n.fa-windows:before {\n  content: \"\\f17a\";\n}\n.fa-android:before {\n  content: \"\\f17b\";\n}\n.fa-linux:before {\n  content: \"\\f17c\";\n}\n.fa-dribbble:before {\n  content: \"\\f17d\";\n}\n.fa-skype:before {\n  content: \"\\f17e\";\n}\n.fa-foursquare:before {\n  content: \"\\f180\";\n}\n.fa-trello:before {\n  content: \"\\f181\";\n}\n.fa-female:before {\n  content: \"\\f182\";\n}\n.fa-male:before {\n  content: \"\\f183\";\n}\n.fa-gittip:before,\n.fa-gratipay:before {\n  content: \"\\f184\";\n}\n.fa-sun-o:before {\n  content: \"\\f185\";\n}\n.fa-moon-o:before {\n  content: \"\\f186\";\n}\n.fa-archive:before {\n  content: \"\\f187\";\n}\n.fa-bug:before {\n  content: \"\\f188\";\n}\n.fa-vk:before {\n  content: \"\\f189\";\n}\n.fa-weibo:before {\n  content: \"\\f18a\";\n}\n.fa-renren:before {\n  content: \"\\f18b\";\n}\n.fa-pagelines:before {\n  content: \"\\f18c\";\n}\n.fa-stack-exchange:before {\n  content: \"\\f18d\";\n}\n.fa-arrow-circle-o-right:before {\n  content: \"\\f18e\";\n}\n.fa-arrow-circle-o-left:before {\n  content: \"\\f190\";\n}\n.fa-toggle-left:before,\n.fa-caret-square-o-left:before {\n  content: \"\\f191\";\n}\n.fa-dot-circle-o:before {\n  content: \"\\f192\";\n}\n.fa-wheelchair:before {\n  content: \"\\f193\";\n}\n.fa-vimeo-square:before {\n  content: \"\\f194\";\n}\n.fa-turkish-lira:before,\n.fa-try:before {\n  content: \"\\f195\";\n}\n.fa-plus-square-o:before {\n  content: \"\\f196\";\n}\n.fa-space-shuttle:before {\n  content: \"\\f197\";\n}\n.fa-slack:before {\n  content: \"\\f198\";\n}\n.fa-envelope-square:before {\n  content: \"\\f199\";\n}\n.fa-wordpress:before {\n  content: \"\\f19a\";\n}\n.fa-openid:before {\n  content: \"\\f19b\";\n}\n.fa-institution:before,\n.fa-bank:before,\n.fa-university:before {\n  content: \"\\f19c\";\n}\n.fa-mortar-board:before,\n.fa-graduation-cap:before {\n  content: \"\\f19d\";\n}\n.fa-yahoo:before {\n  content: \"\\f19e\";\n}\n.fa-google:before {\n  content: \"\\f1a0\";\n}\n.fa-reddit:before {\n  content: \"\\f1a1\";\n}\n.fa-reddit-square:before {\n  content: \"\\f1a2\";\n}\n.fa-stumbleupon-circle:before {\n  content: \"\\f1a3\";\n}\n.fa-stumbleupon:before {\n  content: \"\\f1a4\";\n}\n.fa-delicious:before {\n  content: \"\\f1a5\";\n}\n.fa-digg:before {\n  content: \"\\f1a6\";\n}\n.fa-pied-piper:before {\n  content: \"\\f1a7\";\n}\n.fa-pied-piper-alt:before {\n  content: \"\\f1a8\";\n}\n.fa-drupal:before {\n  content: \"\\f1a9\";\n}\n.fa-joomla:before {\n  content: \"\\f1aa\";\n}\n.fa-language:before {\n  content: \"\\f1ab\";\n}\n.fa-fax:before {\n  content: \"\\f1ac\";\n}\n.fa-building:before {\n  content: \"\\f1ad\";\n}\n.fa-child:before {\n  content: \"\\f1ae\";\n}\n.fa-paw:before {\n  content: \"\\f1b0\";\n}\n.fa-spoon:before {\n  content: \"\\f1b1\";\n}\n.fa-cube:before {\n  content: \"\\f1b2\";\n}\n.fa-cubes:before {\n  content: \"\\f1b3\";\n}\n.fa-behance:before {\n  content: \"\\f1b4\";\n}\n.fa-behance-square:before {\n  content: \"\\f1b5\";\n}\n.fa-steam:before {\n  content: \"\\f1b6\";\n}\n.fa-steam-square:before {\n  content: \"\\f1b7\";\n}\n.fa-recycle:before {\n  content: \"\\f1b8\";\n}\n.fa-automobile:before,\n.fa-car:before {\n  content: \"\\f1b9\";\n}\n.fa-cab:before,\n.fa-taxi:before {\n  content: \"\\f1ba\";\n}\n.fa-tree:before {\n  content: \"\\f1bb\";\n}\n.fa-spotify:before {\n  content: \"\\f1bc\";\n}\n.fa-deviantart:before {\n  content: \"\\f1bd\";\n}\n.fa-soundcloud:before {\n  content: \"\\f1be\";\n}\n.fa-database:before {\n  content: \"\\f1c0\";\n}\n.fa-file-pdf-o:before {\n  content: \"\\f1c1\";\n}\n.fa-file-word-o:before {\n  content: \"\\f1c2\";\n}\n.fa-file-excel-o:before {\n  content: \"\\f1c3\";\n}\n.fa-file-powerpoint-o:before {\n  content: \"\\f1c4\";\n}\n.fa-file-photo-o:before,\n.fa-file-picture-o:before,\n.fa-file-image-o:before {\n  content: \"\\f1c5\";\n}\n.fa-file-zip-o:before,\n.fa-file-archive-o:before {\n  content: \"\\f1c6\";\n}\n.fa-file-sound-o:before,\n.fa-file-audio-o:before {\n  content: \"\\f1c7\";\n}\n.fa-file-movie-o:before,\n.fa-file-video-o:before {\n  content: \"\\f1c8\";\n}\n.fa-file-code-o:before {\n  content: \"\\f1c9\";\n}\n.fa-vine:before {\n  content: \"\\f1ca\";\n}\n.fa-codepen:before {\n  content: \"\\f1cb\";\n}\n.fa-jsfiddle:before {\n  content: \"\\f1cc\";\n}\n.fa-life-bouy:before,\n.fa-life-buoy:before,\n.fa-life-saver:before,\n.fa-support:before,\n.fa-life-ring:before {\n  content: \"\\f1cd\";\n}\n.fa-circle-o-notch:before {\n  content: \"\\f1ce\";\n}\n.fa-ra:before,\n.fa-rebel:before {\n  content: \"\\f1d0\";\n}\n.fa-ge:before,\n.fa-empire:before {\n  content: \"\\f1d1\";\n}\n.fa-git-square:before {\n  content: \"\\f1d2\";\n}\n.fa-git:before {\n  content: \"\\f1d3\";\n}\n.fa-hacker-news:before {\n  content: \"\\f1d4\";\n}\n.fa-tencent-weibo:before {\n  content: \"\\f1d5\";\n}\n.fa-qq:before {\n  content: \"\\f1d6\";\n}\n.fa-wechat:before,\n.fa-weixin:before {\n  content: \"\\f1d7\";\n}\n.fa-send:before,\n.fa-paper-plane:before {\n  content: \"\\f1d8\";\n}\n.fa-send-o:before,\n.fa-paper-plane-o:before {\n  content: \"\\f1d9\";\n}\n.fa-history:before {\n  content: \"\\f1da\";\n}\n.fa-genderless:before,\n.fa-circle-thin:before {\n  content: \"\\f1db\";\n}\n.fa-header:before {\n  content: \"\\f1dc\";\n}\n.fa-paragraph:before {\n  content: \"\\f1dd\";\n}\n.fa-sliders:before {\n  content: \"\\f1de\";\n}\n.fa-share-alt:before {\n  content: \"\\f1e0\";\n}\n.fa-share-alt-square:before {\n  content: \"\\f1e1\";\n}\n.fa-bomb:before {\n  content: \"\\f1e2\";\n}\n.fa-soccer-ball-o:before,\n.fa-futbol-o:before {\n  content: \"\\f1e3\";\n}\n.fa-tty:before {\n  content: \"\\f1e4\";\n}\n.fa-binoculars:before {\n  content: \"\\f1e5\";\n}\n.fa-plug:before {\n  content: \"\\f1e6\";\n}\n.fa-slideshare:before {\n  content: \"\\f1e7\";\n}\n.fa-twitch:before {\n  content: \"\\f1e8\";\n}\n.fa-yelp:before {\n  content: \"\\f1e9\";\n}\n.fa-newspaper-o:before {\n  content: \"\\f1ea\";\n}\n.fa-wifi:before {\n  content: \"\\f1eb\";\n}\n.fa-calculator:before {\n  content: \"\\f1ec\";\n}\n.fa-paypal:before {\n  content: \"\\f1ed\";\n}\n.fa-google-wallet:before {\n  content: \"\\f1ee\";\n}\n.fa-cc-visa:before {\n  content: \"\\f1f0\";\n}\n.fa-cc-mastercard:before {\n  content: \"\\f1f1\";\n}\n.fa-cc-discover:before {\n  content: \"\\f1f2\";\n}\n.fa-cc-amex:before {\n  content: \"\\f1f3\";\n}\n.fa-cc-paypal:before {\n  content: \"\\f1f4\";\n}\n.fa-cc-stripe:before {\n  content: \"\\f1f5\";\n}\n.fa-bell-slash:before {\n  content: \"\\f1f6\";\n}\n.fa-bell-slash-o:before {\n  content: \"\\f1f7\";\n}\n.fa-trash:before {\n  content: \"\\f1f8\";\n}\n.fa-copyright:before {\n  content: \"\\f1f9\";\n}\n.fa-at:before {\n  content: \"\\f1fa\";\n}\n.fa-eyedropper:before {\n  content: \"\\f1fb\";\n}\n.fa-paint-brush:before {\n  content: \"\\f1fc\";\n}\n.fa-birthday-cake:before {\n  content: \"\\f1fd\";\n}\n.fa-area-chart:before {\n  content: \"\\f1fe\";\n}\n.fa-pie-chart:before {\n  content: \"\\f200\";\n}\n.fa-line-chart:before {\n  content: \"\\f201\";\n}\n.fa-lastfm:before {\n  content: \"\\f202\";\n}\n.fa-lastfm-square:before {\n  content: \"\\f203\";\n}\n.fa-toggle-off:before {\n  content: \"\\f204\";\n}\n.fa-toggle-on:before {\n  content: \"\\f205\";\n}\n.fa-bicycle:before {\n  content: \"\\f206\";\n}\n.fa-bus:before {\n  content: \"\\f207\";\n}\n.fa-ioxhost:before {\n  content: \"\\f208\";\n}\n.fa-angellist:before {\n  content: \"\\f209\";\n}\n.fa-cc:before {\n  content: \"\\f20a\";\n}\n.fa-shekel:before,\n.fa-sheqel:before,\n.fa-ils:before {\n  content: \"\\f20b\";\n}\n.fa-meanpath:before {\n  content: \"\\f20c\";\n}\n.fa-buysellads:before {\n  content: \"\\f20d\";\n}\n.fa-connectdevelop:before {\n  content: \"\\f20e\";\n}\n.fa-dashcube:before {\n  content: \"\\f210\";\n}\n.fa-forumbee:before {\n  content: \"\\f211\";\n}\n.fa-leanpub:before {\n  content: \"\\f212\";\n}\n.fa-sellsy:before {\n  content: \"\\f213\";\n}\n.fa-shirtsinbulk:before {\n  content: \"\\f214\";\n}\n.fa-simplybuilt:before {\n  content: \"\\f215\";\n}\n.fa-skyatlas:before {\n  content: \"\\f216\";\n}\n.fa-cart-plus:before {\n  content: \"\\f217\";\n}\n.fa-cart-arrow-down:before {\n  content: \"\\f218\";\n}\n.fa-diamond:before {\n  content: \"\\f219\";\n}\n.fa-ship:before {\n  content: \"\\f21a\";\n}\n.fa-user-secret:before {\n  content: \"\\f21b\";\n}\n.fa-motorcycle:before {\n  content: \"\\f21c\";\n}\n.fa-street-view:before {\n  content: \"\\f21d\";\n}\n.fa-heartbeat:before {\n  content: \"\\f21e\";\n}\n.fa-venus:before {\n  content: \"\\f221\";\n}\n.fa-mars:before {\n  content: \"\\f222\";\n}\n.fa-mercury:before {\n  content: \"\\f223\";\n}\n.fa-transgender:before {\n  content: \"\\f224\";\n}\n.fa-transgender-alt:before {\n  content: \"\\f225\";\n}\n.fa-venus-double:before {\n  content: \"\\f226\";\n}\n.fa-mars-double:before {\n  content: \"\\f227\";\n}\n.fa-venus-mars:before {\n  content: \"\\f228\";\n}\n.fa-mars-stroke:before {\n  content: \"\\f229\";\n}\n.fa-mars-stroke-v:before {\n  content: \"\\f22a\";\n}\n.fa-mars-stroke-h:before {\n  content: \"\\f22b\";\n}\n.fa-neuter:before {\n  content: \"\\f22c\";\n}\n.fa-facebook-official:before {\n  content: \"\\f230\";\n}\n.fa-pinterest-p:before {\n  content: \"\\f231\";\n}\n.fa-whatsapp:before {\n  content: \"\\f232\";\n}\n.fa-server:before {\n  content: \"\\f233\";\n}\n.fa-user-plus:before {\n  content: \"\\f234\";\n}\n.fa-user-times:before {\n  content: \"\\f235\";\n}\n.fa-hotel:before,\n.fa-bed:before {\n  content: \"\\f236\";\n}\n.fa-viacoin:before {\n  content: \"\\f237\";\n}\n.fa-train:before {\n  content: \"\\f238\";\n}\n.fa-subway:before {\n  content: \"\\f239\";\n}\n.fa-medium:before {\n  content: \"\\f23a\";\n}\n","// Core variables and mixins\r\n@import \"variables.less\";\r\n@import \"mixins.less\";\r\n\r\n// Core CSS\r\n.layout-editor {\r\n    @import \"scaffolding.less\";\r\n    @import \"grid.less\";\r\n}\r\n \r\n// Utility classes\r\n@import \"utilities.less\";\r\n","// Vendor Prefixes\r\n//\r\n// All vendor mixins are deprecated as of v3.2.0 due to the introduction of\r\n// Autoprefixer in our Gruntfile. They will be removed in v4.\r\n\r\n// - Animations\r\n// - Backface visibility\r\n// - Box shadow\r\n// - Box sizing\r\n// - Content columns\r\n// - Hyphens\r\n// - Placeholder text\r\n// - Transformations\r\n// - Transitions\r\n// - User Select\r\n\r\n\r\n// Animations\r\n.animation(@animation) {\r\n  -webkit-animation: @animation;\r\n       -o-animation: @animation;\r\n          animation: @animation;\r\n}\r\n.animation-name(@name) {\r\n  -webkit-animation-name: @name;\r\n          animation-name: @name;\r\n}\r\n.animation-duration(@duration) {\r\n  -webkit-animation-duration: @duration;\r\n          animation-duration: @duration;\r\n}\r\n.animation-timing-function(@timing-function) {\r\n  -webkit-animation-timing-function: @timing-function;\r\n          animation-timing-function: @timing-function;\r\n}\r\n.animation-delay(@delay) {\r\n  -webkit-animation-delay: @delay;\r\n          animation-delay: @delay;\r\n}\r\n.animation-iteration-count(@iteration-count) {\r\n  -webkit-animation-iteration-count: @iteration-count;\r\n          animation-iteration-count: @iteration-count;\r\n}\r\n.animation-direction(@direction) {\r\n  -webkit-animation-direction: @direction;\r\n          animation-direction: @direction;\r\n}\r\n.animation-fill-mode(@fill-mode) {\r\n  -webkit-animation-fill-mode: @fill-mode;\r\n          animation-fill-mode: @fill-mode;\r\n}\r\n\r\n// Backface visibility\r\n// Prevent browsers from flickering when using CSS 3D transforms.\r\n// Default value is `visible`, but can be changed to `hidden`\r\n\r\n.backface-visibility(@visibility){\r\n  -webkit-backface-visibility: @visibility;\r\n     -moz-backface-visibility: @visibility;\r\n          backface-visibility: @visibility;\r\n}\r\n\r\n// Drop shadows\r\n//\r\n// Note: Deprecated `.box-shadow()` as of v3.1.0 since all of Bootstrap's\r\n// supported browsers that have box shadow capabilities now support it.\r\n\r\n.box-shadow(@shadow) {\r\n  -webkit-box-shadow: @shadow; // iOS <4.3 & Android <4.1\r\n          box-shadow: @shadow;\r\n}\r\n\r\n// Box sizing\r\n.box-sizing(@boxmodel) {\r\n  -webkit-box-sizing: @boxmodel;\r\n     -moz-box-sizing: @boxmodel;\r\n          box-sizing: @boxmodel;\r\n}\r\n\r\n// CSS3 Content Columns\r\n.content-columns(@column-count; @column-gap: @grid-gutter-width) {\r\n  -webkit-column-count: @column-count;\r\n     -moz-column-count: @column-count;\r\n          column-count: @column-count;\r\n  -webkit-column-gap: @column-gap;\r\n     -moz-column-gap: @column-gap;\r\n          column-gap: @column-gap;\r\n}\r\n\r\n// Optional hyphenation\r\n.hyphens(@mode: auto) {\r\n  word-wrap: break-word;\r\n  -webkit-hyphens: @mode;\r\n     -moz-hyphens: @mode;\r\n      -ms-hyphens: @mode; // IE10+\r\n       -o-hyphens: @mode;\r\n          hyphens: @mode;\r\n}\r\n\r\n// Placeholder text\r\n.placeholder(@color: @input-color-placeholder) {\r\n  // Firefox\r\n  &::-moz-placeholder {\r\n    color: @color;\r\n    opacity: 1; // See https://github.com/twbs/bootstrap/pull/11526\r\n  }\r\n  &:-ms-input-placeholder { color: @color; } // Internet Explorer 10+\r\n  &::-webkit-input-placeholder  { color: @color; } // Safari and Chrome\r\n}\r\n\r\n// Transformations\r\n.scale(@ratio) {\r\n  -webkit-transform: scale(@ratio);\r\n      -ms-transform: scale(@ratio); // IE9 only\r\n       -o-transform: scale(@ratio);\r\n          transform: scale(@ratio);\r\n}\r\n.scale(@ratioX; @ratioY) {\r\n  -webkit-transform: scale(@ratioX, @ratioY);\r\n      -ms-transform: scale(@ratioX, @ratioY); // IE9 only\r\n       -o-transform: scale(@ratioX, @ratioY);\r\n          transform: scale(@ratioX, @ratioY);\r\n}\r\n.scaleX(@ratio) {\r\n  -webkit-transform: scaleX(@ratio);\r\n      -ms-transform: scaleX(@ratio); // IE9 only\r\n       -o-transform: scaleX(@ratio);\r\n          transform: scaleX(@ratio);\r\n}\r\n.scaleY(@ratio) {\r\n  -webkit-transform: scaleY(@ratio);\r\n      -ms-transform: scaleY(@ratio); // IE9 only\r\n       -o-transform: scaleY(@ratio);\r\n          transform: scaleY(@ratio);\r\n}\r\n.skew(@x; @y) {\r\n  -webkit-transform: skewX(@x) skewY(@y);\r\n      -ms-transform: skewX(@x) skewY(@y); // See https://github.com/twbs/bootstrap/issues/4885; IE9+\r\n       -o-transform: skewX(@x) skewY(@y);\r\n          transform: skewX(@x) skewY(@y);\r\n}\r\n.translate(@x; @y) {\r\n  -webkit-transform: translate(@x, @y);\r\n      -ms-transform: translate(@x, @y); // IE9 only\r\n       -o-transform: translate(@x, @y);\r\n          transform: translate(@x, @y);\r\n}\r\n.translate3d(@x; @y; @z) {\r\n  -webkit-transform: translate3d(@x, @y, @z);\r\n          transform: translate3d(@x, @y, @z);\r\n}\r\n.rotate(@degrees) {\r\n  -webkit-transform: rotate(@degrees);\r\n      -ms-transform: rotate(@degrees); // IE9 only\r\n       -o-transform: rotate(@degrees);\r\n          transform: rotate(@degrees);\r\n}\r\n.rotateX(@degrees) {\r\n  -webkit-transform: rotateX(@degrees);\r\n      -ms-transform: rotateX(@degrees); // IE9 only\r\n       -o-transform: rotateX(@degrees);\r\n          transform: rotateX(@degrees);\r\n}\r\n.rotateY(@degrees) {\r\n  -webkit-transform: rotateY(@degrees);\r\n      -ms-transform: rotateY(@degrees); // IE9 only\r\n       -o-transform: rotateY(@degrees);\r\n          transform: rotateY(@degrees);\r\n}\r\n.perspective(@perspective) {\r\n  -webkit-perspective: @perspective;\r\n     -moz-perspective: @perspective;\r\n          perspective: @perspective;\r\n}\r\n.perspective-origin(@perspective) {\r\n  -webkit-perspective-origin: @perspective;\r\n     -moz-perspective-origin: @perspective;\r\n          perspective-origin: @perspective;\r\n}\r\n.transform-origin(@origin) {\r\n  -webkit-transform-origin: @origin;\r\n     -moz-transform-origin: @origin;\r\n      -ms-transform-origin: @origin; // IE9 only\r\n          transform-origin: @origin;\r\n}\r\n\r\n\r\n// Transitions\r\n\r\n.transition(@transition) {\r\n  -webkit-transition: @transition;\r\n       -o-transition: @transition;\r\n          transition: @transition;\r\n}\r\n.transition-property(@transition-property) {\r\n  -webkit-transition-property: @transition-property;\r\n          transition-property: @transition-property;\r\n}\r\n.transition-delay(@transition-delay) {\r\n  -webkit-transition-delay: @transition-delay;\r\n          transition-delay: @transition-delay;\r\n}\r\n.transition-duration(@transition-duration) {\r\n  -webkit-transition-duration: @transition-duration;\r\n          transition-duration: @transition-duration;\r\n}\r\n.transition-timing-function(@timing-function) {\r\n  -webkit-transition-timing-function: @timing-function;\r\n          transition-timing-function: @timing-function;\r\n}\r\n.transition-transform(@transition) {\r\n  -webkit-transition: -webkit-transform @transition;\r\n     -moz-transition: -moz-transform @transition;\r\n       -o-transition: -o-transform @transition;\r\n          transition: transform @transition;\r\n}\r\n\r\n\r\n// User select\r\n// For selecting text on the page\r\n\r\n.user-select(@select) {\r\n  -webkit-user-select: @select;\r\n     -moz-user-select: @select;\r\n      -ms-user-select: @select; // IE10+\r\n          user-select: @select;\r\n}\r\n","//\r\n// Scaffolding\r\n// --------------------------------------------------\r\n\r\n\r\n// Reset the box-sizing\r\n//\r\n// Heads up! This reset may cause conflicts with some third-party widgets.\r\n// For recommendations on resolving such conflicts, see\r\n// http://getbootstrap.com/getting-started/#third-box-sizing\r\n* {\r\n  .box-sizing(border-box);\r\n}\r\n*:before,\r\n*:after {\r\n  .box-sizing(border-box);\r\n}\r\n\r\n\r\n// Body reset\r\n\r\nhtml {\r\n  font-size: 10px;\r\n  -webkit-tap-highlight-color: rgba(0,0,0,0);\r\n}\r\n\r\nbody {\r\n  font-family: @font-family-base;\r\n  font-size: @font-size-base;\r\n  line-height: @line-height-base;\r\n  color: @text-color;\r\n  background-color: @body-bg;\r\n}\r\n\r\n// Reset fonts for relevant elements\r\ninput,\r\nbutton,\r\nselect,\r\ntextarea {\r\n  font-family: inherit;\r\n  font-size: inherit;\r\n  line-height: inherit;\r\n}\r\n\r\n\r\n// Links\r\n\r\na {\r\n  color: @link-color;\r\n  text-decoration: none;\r\n\r\n  &:hover,\r\n  &:focus {\r\n    color: @link-hover-color;\r\n    text-decoration: @link-hover-decoration;\r\n  }\r\n\r\n  &:focus {\r\n    .tab-focus();\r\n  }\r\n}\r\n\r\n\r\n// Figures\r\n//\r\n// We reset this here because previously Normalize had no `figure` margins. This\r\n// ensures we don't break anyone's use of the element.\r\n\r\nfigure {\r\n  margin: 0;\r\n}\r\n\r\n\r\n// Images\r\n\r\nimg {\r\n  vertical-align: middle;\r\n}\r\n\r\n// Responsive images (ensure images don't scale beyond their parents)\r\n.img-responsive {\r\n  .img-responsive();\r\n}\r\n\r\n// Rounded corners\r\n.img-rounded {\r\n  border-radius: @border-radius-large;\r\n}\r\n\r\n// Image thumbnails\r\n//\r\n// Heads up! This is mixin-ed into thumbnails.less for `.thumbnail`.\r\n.img-thumbnail {\r\n  padding: @thumbnail-padding;\r\n  line-height: @line-height-base;\r\n  background-color: @thumbnail-bg;\r\n  border: 1px solid @thumbnail-border;\r\n  border-radius: @thumbnail-border-radius;\r\n  .transition(all .2s ease-in-out);\r\n\r\n  // Keep them at most 100% wide\r\n  .img-responsive(inline-block);\r\n}\r\n\r\n// Perfect circle\r\n.img-circle {\r\n  border-radius: 50%; // set radius in percents\r\n}\r\n\r\n\r\n// Horizontal rules\r\n\r\nhr {\r\n  margin-top:    @line-height-computed;\r\n  margin-bottom: @line-height-computed;\r\n  border: 0;\r\n  border-top: 1px solid @hr-border;\r\n}\r\n\r\n\r\n// Only display content to screen readers\r\n//\r\n// See: http://a11yproject.com/posts/how-to-hide-content/\r\n\r\n.sr-only {\r\n  position: absolute;\r\n  width: 1px;\r\n  height: 1px;\r\n  margin: -1px;\r\n  padding: 0;\r\n  overflow: hidden;\r\n  clip: rect(0,0,0,0);\r\n  border: 0;\r\n}\r\n\r\n// Use in conjunction with .sr-only to only display content when it's focused.\r\n// Useful for \"Skip to main content\" links; see http://www.w3.org/TR/2013/NOTE-WCAG20-TECHS-20130905/G1\r\n// Credit: HTML5 Boilerplate\r\n\r\n.sr-only-focusable {\r\n  &:active,\r\n  &:focus {\r\n    position: static;\r\n    width: auto;\r\n    height: auto;\r\n    margin: 0;\r\n    overflow: visible;\r\n    clip: auto;\r\n  }\r\n}\r\n","// WebKit-style focus\r\n\r\n.tab-focus() {\r\n  // Default\r\n  outline: thin dotted;\r\n  // WebKit\r\n  outline: 5px auto -webkit-focus-ring-color;\r\n  outline-offset: -2px;\r\n}\r\n","// Image Mixins\r\n// - Responsive image\r\n// - Retina image\r\n\r\n\r\n// Responsive image\r\n//\r\n// Keep images from scaling beyond the width of their parents.\r\n.img-responsive(@display: block) {\r\n  display: @display;\r\n  max-width: 100%; // Part 1: Set a maximum relative to the parent\r\n  height: auto; // Part 2: Scale the height according to the width, otherwise you get stretching\r\n}\r\n\r\n\r\n// Retina image\r\n//\r\n// Short retina mixin for setting background-image and -size. Note that the\r\n// spelling of `min--moz-device-pixel-ratio` is intentional.\r\n.img-retina(@file-1x; @file-2x; @width-1x; @height-1x) {\r\n  background-image: url(\"@{file-1x}\");\r\n\r\n  @media\r\n  only screen and (-webkit-min-device-pixel-ratio: 2),\r\n  only screen and (   min--moz-device-pixel-ratio: 2),\r\n  only screen and (     -o-min-device-pixel-ratio: 2/1),\r\n  only screen and (        min-device-pixel-ratio: 2),\r\n  only screen and (                min-resolution: 192dpi),\r\n  only screen and (                min-resolution: 2dppx) {\r\n    background-image: url(\"@{file-2x}\");\r\n    background-size: @width-1x @height-1x;\r\n  }\r\n}\r\n","// Grid system\r\n//\r\n// Generate semantic grid columns with these mixins.\r\n\r\n// Centered container element\r\n.container-fixed(@gutter: @grid-gutter-width) {\r\n  margin-right: auto;\r\n  margin-left: auto;\r\n  padding-left:  (@gutter / 2);\r\n  padding-right: (@gutter / 2);\r\n  &:extend(.clearfix all);\r\n}\r\n\r\n// Creates a wrapper for a series of columns\r\n.make-row(@gutter: @grid-gutter-width) {\r\n  margin-left:  (@gutter / -2);\r\n  margin-right: (@gutter / -2);\r\n  &:extend(.clearfix all);\r\n}\r\n\r\n// Generate the extra small columns\r\n.make-xs-column(@columns; @gutter: @grid-gutter-width) {\r\n  position: relative;\r\n  float: left;\r\n  width: percentage((@columns / @grid-columns));\r\n  min-height: 1px;\r\n  padding-left:  (@gutter / 2);\r\n  padding-right: (@gutter / 2);\r\n}\r\n.make-xs-column-offset(@columns) {\r\n  margin-left: percentage((@columns / @grid-columns));\r\n}\r\n.make-xs-column-push(@columns) {\r\n  left: percentage((@columns / @grid-columns));\r\n}\r\n.make-xs-column-pull(@columns) {\r\n  right: percentage((@columns / @grid-columns));\r\n}\r\n\r\n// Generate the small columns\r\n.make-sm-column(@columns; @gutter: @grid-gutter-width) {\r\n  position: relative;\r\n  min-height: 1px;\r\n  padding-left:  (@gutter / 2);\r\n  padding-right: (@gutter / 2);\r\n\r\n  @media (min-width: @screen-sm-min) {\r\n    float: left;\r\n    width: percentage((@columns / @grid-columns));\r\n  }\r\n}\r\n.make-sm-column-offset(@columns) {\r\n  @media (min-width: @screen-sm-min) {\r\n    margin-left: percentage((@columns / @grid-columns));\r\n  }\r\n}\r\n.make-sm-column-push(@columns) {\r\n  @media (min-width: @screen-sm-min) {\r\n    left: percentage((@columns / @grid-columns));\r\n  }\r\n}\r\n.make-sm-column-pull(@columns) {\r\n  @media (min-width: @screen-sm-min) {\r\n    right: percentage((@columns / @grid-columns));\r\n  }\r\n}\r\n\r\n// Generate the medium columns\r\n.make-md-column(@columns; @gutter: @grid-gutter-width) {\r\n  position: relative;\r\n  min-height: 1px;\r\n  padding-left:  (@gutter / 2);\r\n  padding-right: (@gutter / 2);\r\n\r\n  @media (min-width: @screen-md-min) {\r\n    float: left;\r\n    width: percentage((@columns / @grid-columns));\r\n  }\r\n}\r\n.make-md-column-offset(@columns) {\r\n  @media (min-width: @screen-md-min) {\r\n    margin-left: percentage((@columns / @grid-columns));\r\n  }\r\n}\r\n.make-md-column-push(@columns) {\r\n  @media (min-width: @screen-md-min) {\r\n    left: percentage((@columns / @grid-columns));\r\n  }\r\n}\r\n.make-md-column-pull(@columns) {\r\n  @media (min-width: @screen-md-min) {\r\n    right: percentage((@columns / @grid-columns));\r\n  }\r\n}\r\n\r\n// Generate the large columns\r\n.make-lg-column(@columns; @gutter: @grid-gutter-width) {\r\n  position: relative;\r\n  min-height: 1px;\r\n  padding-left:  (@gutter / 2);\r\n  padding-right: (@gutter / 2);\r\n\r\n  @media (min-width: @screen-lg-min) {\r\n    float: left;\r\n    width: percentage((@columns / @grid-columns));\r\n  }\r\n}\r\n.make-lg-column-offset(@columns) {\r\n  @media (min-width: @screen-lg-min) {\r\n    margin-left: percentage((@columns / @grid-columns));\r\n  }\r\n}\r\n.make-lg-column-push(@columns) {\r\n  @media (min-width: @screen-lg-min) {\r\n    left: percentage((@columns / @grid-columns));\r\n  }\r\n}\r\n.make-lg-column-pull(@columns) {\r\n  @media (min-width: @screen-lg-min) {\r\n    right: percentage((@columns / @grid-columns));\r\n  }\r\n}\r\n","//\r\n// Grid system\r\n// --------------------------------------------------\r\n\r\n\r\n// Container widths\r\n//\r\n// Set the container width, and override it for fixed navbars in media queries.\r\n\r\n.container {\r\n  .container-fixed();\r\n\r\n  @media (min-width: @screen-sm-min) {\r\n    width: @container-sm;\r\n  }\r\n  @media (min-width: @screen-md-min) {\r\n    width: @container-md;\r\n  }\r\n  @media (min-width: @screen-lg-min) {\r\n    width: @container-lg;\r\n  }\r\n}\r\n\r\n\r\n// Fluid container\r\n//\r\n// Utilizes the mixin meant for fixed width containers, but without any defined\r\n// width for fluid, full width layouts.\r\n\r\n.container-fluid {\r\n  .container-fixed();\r\n}\r\n\r\n\r\n// Row\r\n//\r\n// Rows contain and clear the floats of your columns.\r\n\r\n.row {\r\n  .make-row();\r\n}\r\n\r\n\r\n// Columns\r\n//\r\n// Common styles for small and large grid columns\r\n\r\n.make-grid-columns();\r\n\r\n\r\n// Extra small grid\r\n//\r\n// Columns, offsets, pushes, and pulls for extra small devices like\r\n// smartphones.\r\n\r\n.make-grid(xs);\r\n\r\n\r\n// Small grid\r\n//\r\n// Columns, offsets, pushes, and pulls for the small device range, from phones\r\n// to tablets.\r\n\r\n@media (min-width: @screen-sm-min) {\r\n  .make-grid(sm);\r\n}\r\n\r\n\r\n// Medium grid\r\n//\r\n// Columns, offsets, pushes, and pulls for the desktop device range.\r\n\r\n@media (min-width: @screen-md-min) {\r\n  .make-grid(md);\r\n}\r\n\r\n\r\n// Large grid\r\n//\r\n// Columns, offsets, pushes, and pulls for the large desktop device range.\r\n\r\n@media (min-width: @screen-lg-min) {\r\n  .make-grid(lg);\r\n}\r\n","// Framework grid generation\r\n//\r\n// Used only by Bootstrap to generate the correct number of grid classes given\r\n// any value of `@grid-columns`.\r\n\r\n.make-grid-columns() {\r\n  // Common styles for all sizes of grid columns, widths 1-12\r\n  .col(@index) { // initial\r\n    @item: ~\".col-xs-@{index}, .col-sm-@{index}, .col-md-@{index}, .col-lg-@{index}\";\r\n    .col((@index + 1), @item);\r\n  }\r\n  .col(@index, @list) when (@index =< @grid-columns) { // general; \"=<\" isn't a typo\r\n    @item: ~\".col-xs-@{index}, .col-sm-@{index}, .col-md-@{index}, .col-lg-@{index}\";\r\n    .col((@index + 1), ~\"@{list}, @{item}\");\r\n  }\r\n  .col(@index, @list) when (@index > @grid-columns) { // terminal\r\n    @{list} {\r\n      position: relative;\r\n      // Prevent columns from collapsing when empty\r\n      min-height: 1px;\r\n      // Inner gutter via padding\r\n      padding-left:  (@grid-gutter-width / 2);\r\n      padding-right: (@grid-gutter-width / 2);\r\n    }\r\n  }\r\n  .col(1); // kickstart it\r\n}\r\n\r\n.float-grid-columns(@class) {\r\n  .col(@index) { // initial\r\n    @item: ~\".col-@{class}-@{index}\";\r\n    .col((@index + 1), @item);\r\n  }\r\n  .col(@index, @list) when (@index =< @grid-columns) { // general\r\n    @item: ~\".col-@{class}-@{index}\";\r\n    .col((@index + 1), ~\"@{list}, @{item}\");\r\n  }\r\n  .col(@index, @list) when (@index > @grid-columns) { // terminal\r\n    @{list} {\r\n      float: left;\r\n    }\r\n  }\r\n  .col(1); // kickstart it\r\n}\r\n\r\n.calc-grid-column(@index, @class, @type) when (@type = width) and (@index > 0) {\r\n  .col-@{class}-@{index} {\r\n    width: percentage((@index / @grid-columns));\r\n  }\r\n}\r\n.calc-grid-column(@index, @class, @type) when (@type = push) and (@index > 0) {\r\n  .col-@{class}-push-@{index} {\r\n    left: percentage((@index / @grid-columns));\r\n  }\r\n}\r\n.calc-grid-column(@index, @class, @type) when (@type = push) and (@index = 0) {\r\n  .col-@{class}-push-0 {\r\n    left: auto;\r\n  }\r\n}\r\n.calc-grid-column(@index, @class, @type) when (@type = pull) and (@index > 0) {\r\n  .col-@{class}-pull-@{index} {\r\n    right: percentage((@index / @grid-columns));\r\n  }\r\n}\r\n.calc-grid-column(@index, @class, @type) when (@type = pull) and (@index = 0) {\r\n  .col-@{class}-pull-0 {\r\n    right: auto;\r\n  }\r\n}\r\n.calc-grid-column(@index, @class, @type) when (@type = offset) {\r\n  .col-@{class}-offset-@{index} {\r\n    margin-left: percentage((@index / @grid-columns));\r\n  }\r\n}\r\n\r\n// Basic looping in LESS\r\n.loop-grid-columns(@index, @class, @type) when (@index >= 0) {\r\n  .calc-grid-column(@index, @class, @type);\r\n  // next iteration\r\n  .loop-grid-columns((@index - 1), @class, @type);\r\n}\r\n\r\n// Create grid for specific class\r\n.make-grid(@class) {\r\n  .float-grid-columns(@class);\r\n  .loop-grid-columns(@grid-columns, @class, width);\r\n  .loop-grid-columns(@grid-columns, @class, pull);\r\n  .loop-grid-columns(@grid-columns, @class, push);\r\n  .loop-grid-columns(@grid-columns, @class, offset);\r\n}\r\n","// Clearfix\r\n//\r\n// For modern browsers\r\n// 1. The space content is one way to avoid an Opera bug when the\r\n//    contenteditable attribute is included anywhere else in the document.\r\n//    Otherwise it causes space to appear at the top and bottom of elements\r\n//    that are clearfixed.\r\n// 2. The use of `table` rather than `block` is only necessary if using\r\n//    `:before` to contain the top-margins of child elements.\r\n//\r\n// Source: http://nicolasgallagher.com/micro-clearfix-hack/\r\n\r\n.clearfix() {\r\n  &:before,\r\n  &:after {\r\n    content: \" \"; // 1\r\n    display: table; // 2\r\n  }\r\n  &:after {\r\n    clear: both;\r\n  }\r\n}\r\n","//\r\n// Utility classes\r\n// --------------------------------------------------\r\n\r\n\r\n// Floats\r\n// -------------------------\r\n\r\n.clearfix {\r\n  .clearfix();\r\n}\r\n.center-block {\r\n  .center-block();\r\n}\r\n.pull-right {\r\n  float: right !important;\r\n}\r\n.pull-left {\r\n  float: left !important;\r\n}\r\n\r\n\r\n// Toggling content\r\n// -------------------------\r\n\r\n// Note: Deprecated .hide in favor of .hidden or .sr-only (as appropriate) in v3.0.1\r\n.hide {\r\n  display: none !important;\r\n}\r\n.show {\r\n  display: block !important;\r\n}\r\n.invisible {\r\n  visibility: hidden;\r\n}\r\n.text-hide {\r\n  .text-hide();\r\n}\r\n\r\n\r\n// Hide from screenreaders and browsers\r\n//\r\n// Credit: HTML5 Boilerplate\r\n\r\n.hidden {\r\n  display: none !important;\r\n  visibility: hidden !important;\r\n}\r\n\r\n\r\n// For Affix plugin\r\n// -------------------------\r\n\r\n.affix {\r\n  position: fixed;\r\n}\r\n","// Center-align a block level element\r\n\r\n.center-block() {\r\n  display: block;\r\n  margin-left: auto;\r\n  margin-right: auto;\r\n}\r\n","// CSS image replacement\r\n//\r\n// Heads up! v3 launched with with only `.hide-text()`, but per our pattern for\r\n// mixins being reused as classes with the same name, this doesn't hold up. As\r\n// of v3.0.1 we have added `.text-hide()` and deprecated `.hide-text()`.\r\n//\r\n// Source: https://github.com/h5bp/html5-boilerplate/commit/aa0396eae757\r\n\r\n// Deprecated as of v3.0.1 (will be removed in v4)\r\n.hide-text() {\r\n  font: ~\"0/0\" a;\r\n  color: transparent;\r\n  text-shadow: none;\r\n  background-color: transparent;\r\n  border: 0;\r\n}\r\n\r\n// New mixin to use as of v3.0.1\r\n.text-hide() {\r\n  .hide-text();\r\n}\r\n","/* FONT PATH\r\n * -------------------------- */\r\n\r\n@font-face {\r\n  font-family: 'FontAwesome';\r\n  src: url('@{fa-font-path}/fontawesome-webfont.eot?v=@{fa-version}');\r\n  src: url('@{fa-font-path}/fontawesome-webfont.eot?#iefix&v=@{fa-version}') format('embedded-opentype'),\r\n    url('@{fa-font-path}/fontawesome-webfont.woff2?v=@{fa-version}') format('woff2'),\r\n    url('@{fa-font-path}/fontawesome-webfont.woff?v=@{fa-version}') format('woff'),\r\n    url('@{fa-font-path}/fontawesome-webfont.ttf?v=@{fa-version}') format('truetype'),\r\n    url('@{fa-font-path}/fontawesome-webfont.svg?v=@{fa-version}#fontawesomeregular') format('svg');\r\n//  src: url('@{fa-font-path}/FontAwesome.otf') format('opentype'); // used when developing fonts\r\n  font-weight: normal;\r\n  font-style: normal;\r\n}\r\n","// Base Class Definition\r\n// -------------------------\r\n\r\n.@{fa-css-prefix} {\r\n  display: inline-block;\r\n  font: normal normal normal @fa-font-size-base/1 FontAwesome; // shortening font declaration\r\n  font-size: inherit; // can't have font-size inherit on line above, so need to override\r\n  text-rendering: auto; // optimizelegibility throws things off #1094\r\n  -webkit-font-smoothing: antialiased;\r\n  -moz-osx-font-smoothing: grayscale;\r\n  transform: translate(0, 0); // ensures no half-pixel rendering in firefox\r\n\r\n}\r\n","// Icon Sizes\r\n// -------------------------\r\n\r\n/* makes the font 33% larger relative to the icon container */\r\n.@{fa-css-prefix}-lg {\r\n  font-size: (4em / 3);\r\n  line-height: (3em / 4);\r\n  vertical-align: -15%;\r\n}\r\n.@{fa-css-prefix}-2x { font-size: 2em; }\r\n.@{fa-css-prefix}-3x { font-size: 3em; }\r\n.@{fa-css-prefix}-4x { font-size: 4em; }\r\n.@{fa-css-prefix}-5x { font-size: 5em; }\r\n","// Fixed Width Icons\r\n// -------------------------\r\n.@{fa-css-prefix}-fw {\r\n  width: (18em / 14);\r\n  text-align: center;\r\n}\r\n","// List Icons\r\n// -------------------------\r\n\r\n.@{fa-css-prefix}-ul {\r\n  padding-left: 0;\r\n  margin-left: @fa-li-width;\r\n  list-style-type: none;\r\n  > li { position: relative; }\r\n}\r\n.@{fa-css-prefix}-li {\r\n  position: absolute;\r\n  left: -@fa-li-width;\r\n  width: @fa-li-width;\r\n  top: (2em / 14);\r\n  text-align: center;\r\n  &.@{fa-css-prefix}-lg {\r\n    left: (-@fa-li-width + (4em / 14));\r\n  }\r\n}\r\n","// Bordered & Pulled\r\n// -------------------------\r\n\r\n.@{fa-css-prefix}-border {\r\n  padding: .2em .25em .15em;\r\n  border: solid .08em @fa-border-color;\r\n  border-radius: .1em;\r\n}\r\n\r\n.pull-right { float: right; }\r\n.pull-left { float: left; }\r\n\r\n.@{fa-css-prefix} {\r\n  &.pull-left { margin-right: .3em; }\r\n  &.pull-right { margin-left: .3em; }\r\n}\r\n","// Animated Icons\r\n// --------------------------\r\n\r\n.@{fa-css-prefix}-spin {\r\n  -webkit-animation: fa-spin 2s infinite linear;\r\n          animation: fa-spin 2s infinite linear;\r\n}\r\n\r\n.@{fa-css-prefix}-pulse {\r\n  -webkit-animation: fa-spin 1s infinite steps(8);\r\n          animation: fa-spin 1s infinite steps(8);\r\n}\r\n\r\n@-webkit-keyframes fa-spin {\r\n  0% {\r\n    -webkit-transform: rotate(0deg);\r\n            transform: rotate(0deg);\r\n  }\r\n  100% {\r\n    -webkit-transform: rotate(359deg);\r\n            transform: rotate(359deg);\r\n  }\r\n}\r\n\r\n@keyframes fa-spin {\r\n  0% {\r\n    -webkit-transform: rotate(0deg);\r\n            transform: rotate(0deg);\r\n  }\r\n  100% {\r\n    -webkit-transform: rotate(359deg);\r\n            transform: rotate(359deg);\r\n  }\r\n}\r\n","// Rotated & Flipped Icons\r\n// -------------------------\r\n\r\n.@{fa-css-prefix}-rotate-90  { .fa-icon-rotate(90deg, 1);  }\r\n.@{fa-css-prefix}-rotate-180 { .fa-icon-rotate(180deg, 2); }\r\n.@{fa-css-prefix}-rotate-270 { .fa-icon-rotate(270deg, 3); }\r\n\r\n.@{fa-css-prefix}-flip-horizontal { .fa-icon-flip(-1, 1, 0); }\r\n.@{fa-css-prefix}-flip-vertical   { .fa-icon-flip(1, -1, 2); }\r\n\r\n// Hook for IE8-9\r\n// -------------------------\r\n\r\n:root .@{fa-css-prefix}-rotate-90,\r\n:root .@{fa-css-prefix}-rotate-180,\r\n:root .@{fa-css-prefix}-rotate-270,\r\n:root .@{fa-css-prefix}-flip-horizontal,\r\n:root .@{fa-css-prefix}-flip-vertical {\r\n  filter: none;\r\n}\r\n","// Mixins\r\n// --------------------------\r\n\r\n.fa-icon() {\r\n  display: inline-block;\r\n  font: normal normal normal @fa-font-size-base/1 FontAwesome; // shortening font declaration\r\n  font-size: inherit; // can't have font-size inherit on line above, so need to override\r\n  text-rendering: auto; // optimizelegibility throws things off #1094\r\n  -webkit-font-smoothing: antialiased;\r\n  -moz-osx-font-smoothing: grayscale;\r\n  transform: translate(0, 0); // ensures no half-pixel rendering in firefox\r\n\r\n}\r\n\r\n.fa-icon-rotate(@degrees, @rotation) {\r\n  filter: progid:DXImageTransform.Microsoft.BasicImage(rotation=@rotation);\r\n  -webkit-transform: rotate(@degrees);\r\n      -ms-transform: rotate(@degrees);\r\n          transform: rotate(@degrees);\r\n}\r\n\r\n.fa-icon-flip(@horiz, @vert, @rotation) {\r\n  filter: progid:DXImageTransform.Microsoft.BasicImage(rotation=@rotation, mirror=1);\r\n  -webkit-transform: scale(@horiz, @vert);\r\n      -ms-transform: scale(@horiz, @vert);\r\n          transform: scale(@horiz, @vert);\r\n}\r\n","// Stacked Icons\r\n// -------------------------\r\n\r\n.@{fa-css-prefix}-stack {\r\n  position: relative;\r\n  display: inline-block;\r\n  width: 2em;\r\n  height: 2em;\r\n  line-height: 2em;\r\n  vertical-align: middle;\r\n}\r\n.@{fa-css-prefix}-stack-1x, .@{fa-css-prefix}-stack-2x {\r\n  position: absolute;\r\n  left: 0;\r\n  width: 100%;\r\n  text-align: center;\r\n}\r\n.@{fa-css-prefix}-stack-1x { line-height: inherit; }\r\n.@{fa-css-prefix}-stack-2x { font-size: 2em; }\r\n.@{fa-css-prefix}-inverse { color: @fa-inverse; }\r\n","/* Font Awesome uses the Unicode Private Use Area (PUA) to ensure screen\r\n   readers do not read off random characters that represent icons */\r\n\r\n.@{fa-css-prefix}-glass:before { content: @fa-var-glass; }\r\n.@{fa-css-prefix}-music:before { content: @fa-var-music; }\r\n.@{fa-css-prefix}-search:before { content: @fa-var-search; }\r\n.@{fa-css-prefix}-envelope-o:before { content: @fa-var-envelope-o; }\r\n.@{fa-css-prefix}-heart:before { content: @fa-var-heart; }\r\n.@{fa-css-prefix}-star:before { content: @fa-var-star; }\r\n.@{fa-css-prefix}-star-o:before { content: @fa-var-star-o; }\r\n.@{fa-css-prefix}-user:before { content: @fa-var-user; }\r\n.@{fa-css-prefix}-film:before { content: @fa-var-film; }\r\n.@{fa-css-prefix}-th-large:before { content: @fa-var-th-large; }\r\n.@{fa-css-prefix}-th:before { content: @fa-var-th; }\r\n.@{fa-css-prefix}-th-list:before { content: @fa-var-th-list; }\r\n.@{fa-css-prefix}-check:before { content: @fa-var-check; }\r\n.@{fa-css-prefix}-remove:before,\r\n.@{fa-css-prefix}-close:before,\r\n.@{fa-css-prefix}-times:before { content: @fa-var-times; }\r\n.@{fa-css-prefix}-search-plus:before { content: @fa-var-search-plus; }\r\n.@{fa-css-prefix}-search-minus:before { content: @fa-var-search-minus; }\r\n.@{fa-css-prefix}-power-off:before { content: @fa-var-power-off; }\r\n.@{fa-css-prefix}-signal:before { content: @fa-var-signal; }\r\n.@{fa-css-prefix}-gear:before,\r\n.@{fa-css-prefix}-cog:before { content: @fa-var-cog; }\r\n.@{fa-css-prefix}-trash-o:before { content: @fa-var-trash-o; }\r\n.@{fa-css-prefix}-home:before { content: @fa-var-home; }\r\n.@{fa-css-prefix}-file-o:before { content: @fa-var-file-o; }\r\n.@{fa-css-prefix}-clock-o:before { content: @fa-var-clock-o; }\r\n.@{fa-css-prefix}-road:before { content: @fa-var-road; }\r\n.@{fa-css-prefix}-download:before { content: @fa-var-download; }\r\n.@{fa-css-prefix}-arrow-circle-o-down:before { content: @fa-var-arrow-circle-o-down; }\r\n.@{fa-css-prefix}-arrow-circle-o-up:before { content: @fa-var-arrow-circle-o-up; }\r\n.@{fa-css-prefix}-inbox:before { content: @fa-var-inbox; }\r\n.@{fa-css-prefix}-play-circle-o:before { content: @fa-var-play-circle-o; }\r\n.@{fa-css-prefix}-rotate-right:before,\r\n.@{fa-css-prefix}-repeat:before { content: @fa-var-repeat; }\r\n.@{fa-css-prefix}-refresh:before { content: @fa-var-refresh; }\r\n.@{fa-css-prefix}-list-alt:before { content: @fa-var-list-alt; }\r\n.@{fa-css-prefix}-lock:before { content: @fa-var-lock; }\r\n.@{fa-css-prefix}-flag:before { content: @fa-var-flag; }\r\n.@{fa-css-prefix}-headphones:before { content: @fa-var-headphones; }\r\n.@{fa-css-prefix}-volume-off:before { content: @fa-var-volume-off; }\r\n.@{fa-css-prefix}-volume-down:before { content: @fa-var-volume-down; }\r\n.@{fa-css-prefix}-volume-up:before { content: @fa-var-volume-up; }\r\n.@{fa-css-prefix}-qrcode:before { content: @fa-var-qrcode; }\r\n.@{fa-css-prefix}-barcode:before { content: @fa-var-barcode; }\r\n.@{fa-css-prefix}-tag:before { content: @fa-var-tag; }\r\n.@{fa-css-prefix}-tags:before { content: @fa-var-tags; }\r\n.@{fa-css-prefix}-book:before { content: @fa-var-book; }\r\n.@{fa-css-prefix}-bookmark:before { content: @fa-var-bookmark; }\r\n.@{fa-css-prefix}-print:before { content: @fa-var-print; }\r\n.@{fa-css-prefix}-camera:before { content: @fa-var-camera; }\r\n.@{fa-css-prefix}-font:before { content: @fa-var-font; }\r\n.@{fa-css-prefix}-bold:before { content: @fa-var-bold; }\r\n.@{fa-css-prefix}-italic:before { content: @fa-var-italic; }\r\n.@{fa-css-prefix}-text-height:before { content: @fa-var-text-height; }\r\n.@{fa-css-prefix}-text-width:before { content: @fa-var-text-width; }\r\n.@{fa-css-prefix}-align-left:before { content: @fa-var-align-left; }\r\n.@{fa-css-prefix}-align-center:before { content: @fa-var-align-center; }\r\n.@{fa-css-prefix}-align-right:before { content: @fa-var-align-right; }\r\n.@{fa-css-prefix}-align-justify:before { content: @fa-var-align-justify; }\r\n.@{fa-css-prefix}-list:before { content: @fa-var-list; }\r\n.@{fa-css-prefix}-dedent:before,\r\n.@{fa-css-prefix}-outdent:before { content: @fa-var-outdent; }\r\n.@{fa-css-prefix}-indent:before { content: @fa-var-indent; }\r\n.@{fa-css-prefix}-video-camera:before { content: @fa-var-video-camera; }\r\n.@{fa-css-prefix}-photo:before,\r\n.@{fa-css-prefix}-image:before,\r\n.@{fa-css-prefix}-picture-o:before { content: @fa-var-picture-o; }\r\n.@{fa-css-prefix}-pencil:before { content: @fa-var-pencil; }\r\n.@{fa-css-prefix}-map-marker:before { content: @fa-var-map-marker; }\r\n.@{fa-css-prefix}-adjust:before { content: @fa-var-adjust; }\r\n.@{fa-css-prefix}-tint:before { content: @fa-var-tint; }\r\n.@{fa-css-prefix}-edit:before,\r\n.@{fa-css-prefix}-pencil-square-o:before { content: @fa-var-pencil-square-o; }\r\n.@{fa-css-prefix}-share-square-o:before { content: @fa-var-share-square-o; }\r\n.@{fa-css-prefix}-check-square-o:before { content: @fa-var-check-square-o; }\r\n.@{fa-css-prefix}-arrows:before { content: @fa-var-arrows; }\r\n.@{fa-css-prefix}-step-backward:before { content: @fa-var-step-backward; }\r\n.@{fa-css-prefix}-fast-backward:before { content: @fa-var-fast-backward; }\r\n.@{fa-css-prefix}-backward:before { content: @fa-var-backward; }\r\n.@{fa-css-prefix}-play:before { content: @fa-var-play; }\r\n.@{fa-css-prefix}-pause:before { content: @fa-var-pause; }\r\n.@{fa-css-prefix}-stop:before { content: @fa-var-stop; }\r\n.@{fa-css-prefix}-forward:before { content: @fa-var-forward; }\r\n.@{fa-css-prefix}-fast-forward:before { content: @fa-var-fast-forward; }\r\n.@{fa-css-prefix}-step-forward:before { content: @fa-var-step-forward; }\r\n.@{fa-css-prefix}-eject:before { content: @fa-var-eject; }\r\n.@{fa-css-prefix}-chevron-left:before { content: @fa-var-chevron-left; }\r\n.@{fa-css-prefix}-chevron-right:before { content: @fa-var-chevron-right; }\r\n.@{fa-css-prefix}-plus-circle:before { content: @fa-var-plus-circle; }\r\n.@{fa-css-prefix}-minus-circle:before { content: @fa-var-minus-circle; }\r\n.@{fa-css-prefix}-times-circle:before { content: @fa-var-times-circle; }\r\n.@{fa-css-prefix}-check-circle:before { content: @fa-var-check-circle; }\r\n.@{fa-css-prefix}-question-circle:before { content: @fa-var-question-circle; }\r\n.@{fa-css-prefix}-info-circle:before { content: @fa-var-info-circle; }\r\n.@{fa-css-prefix}-crosshairs:before { content: @fa-var-crosshairs; }\r\n.@{fa-css-prefix}-times-circle-o:before { content: @fa-var-times-circle-o; }\r\n.@{fa-css-prefix}-check-circle-o:before { content: @fa-var-check-circle-o; }\r\n.@{fa-css-prefix}-ban:before { content: @fa-var-ban; }\r\n.@{fa-css-prefix}-arrow-left:before { content: @fa-var-arrow-left; }\r\n.@{fa-css-prefix}-arrow-right:before { content: @fa-var-arrow-right; }\r\n.@{fa-css-prefix}-arrow-up:before { content: @fa-var-arrow-up; }\r\n.@{fa-css-prefix}-arrow-down:before { content: @fa-var-arrow-down; }\r\n.@{fa-css-prefix}-mail-forward:before,\r\n.@{fa-css-prefix}-share:before { content: @fa-var-share; }\r\n.@{fa-css-prefix}-expand:before { content: @fa-var-expand; }\r\n.@{fa-css-prefix}-compress:before { content: @fa-var-compress; }\r\n.@{fa-css-prefix}-plus:before { content: @fa-var-plus; }\r\n.@{fa-css-prefix}-minus:before { content: @fa-var-minus; }\r\n.@{fa-css-prefix}-asterisk:before { content: @fa-var-asterisk; }\r\n.@{fa-css-prefix}-exclamation-circle:before { content: @fa-var-exclamation-circle; }\r\n.@{fa-css-prefix}-gift:before { content: @fa-var-gift; }\r\n.@{fa-css-prefix}-leaf:before { content: @fa-var-leaf; }\r\n.@{fa-css-prefix}-fire:before { content: @fa-var-fire; }\r\n.@{fa-css-prefix}-eye:before { content: @fa-var-eye; }\r\n.@{fa-css-prefix}-eye-slash:before { content: @fa-var-eye-slash; }\r\n.@{fa-css-prefix}-warning:before,\r\n.@{fa-css-prefix}-exclamation-triangle:before { content: @fa-var-exclamation-triangle; }\r\n.@{fa-css-prefix}-plane:before { content: @fa-var-plane; }\r\n.@{fa-css-prefix}-calendar:before { content: @fa-var-calendar; }\r\n.@{fa-css-prefix}-random:before { content: @fa-var-random; }\r\n.@{fa-css-prefix}-comment:before { content: @fa-var-comment; }\r\n.@{fa-css-prefix}-magnet:before { content: @fa-var-magnet; }\r\n.@{fa-css-prefix}-chevron-up:before { content: @fa-var-chevron-up; }\r\n.@{fa-css-prefix}-chevron-down:before { content: @fa-var-chevron-down; }\r\n.@{fa-css-prefix}-retweet:before { content: @fa-var-retweet; }\r\n.@{fa-css-prefix}-shopping-cart:before { content: @fa-var-shopping-cart; }\r\n.@{fa-css-prefix}-folder:before { content: @fa-var-folder; }\r\n.@{fa-css-prefix}-folder-open:before { content: @fa-var-folder-open; }\r\n.@{fa-css-prefix}-arrows-v:before { content: @fa-var-arrows-v; }\r\n.@{fa-css-prefix}-arrows-h:before { content: @fa-var-arrows-h; }\r\n.@{fa-css-prefix}-bar-chart-o:before,\r\n.@{fa-css-prefix}-bar-chart:before { content: @fa-var-bar-chart; }\r\n.@{fa-css-prefix}-twitter-square:before { content: @fa-var-twitter-square; }\r\n.@{fa-css-prefix}-facebook-square:before { content: @fa-var-facebook-square; }\r\n.@{fa-css-prefix}-camera-retro:before { content: @fa-var-camera-retro; }\r\n.@{fa-css-prefix}-key:before { content: @fa-var-key; }\r\n.@{fa-css-prefix}-gears:before,\r\n.@{fa-css-prefix}-cogs:before { content: @fa-var-cogs; }\r\n.@{fa-css-prefix}-comments:before { content: @fa-var-comments; }\r\n.@{fa-css-prefix}-thumbs-o-up:before { content: @fa-var-thumbs-o-up; }\r\n.@{fa-css-prefix}-thumbs-o-down:before { content: @fa-var-thumbs-o-down; }\r\n.@{fa-css-prefix}-star-half:before { content: @fa-var-star-half; }\r\n.@{fa-css-prefix}-heart-o:before { content: @fa-var-heart-o; }\r\n.@{fa-css-prefix}-sign-out:before { content: @fa-var-sign-out; }\r\n.@{fa-css-prefix}-linkedin-square:before { content: @fa-var-linkedin-square; }\r\n.@{fa-css-prefix}-thumb-tack:before { content: @fa-var-thumb-tack; }\r\n.@{fa-css-prefix}-external-link:before { content: @fa-var-external-link; }\r\n.@{fa-css-prefix}-sign-in:before { content: @fa-var-sign-in; }\r\n.@{fa-css-prefix}-trophy:before { content: @fa-var-trophy; }\r\n.@{fa-css-prefix}-github-square:before { content: @fa-var-github-square; }\r\n.@{fa-css-prefix}-upload:before { content: @fa-var-upload; }\r\n.@{fa-css-prefix}-lemon-o:before { content: @fa-var-lemon-o; }\r\n.@{fa-css-prefix}-phone:before { content: @fa-var-phone; }\r\n.@{fa-css-prefix}-square-o:before { content: @fa-var-square-o; }\r\n.@{fa-css-prefix}-bookmark-o:before { content: @fa-var-bookmark-o; }\r\n.@{fa-css-prefix}-phone-square:before { content: @fa-var-phone-square; }\r\n.@{fa-css-prefix}-twitter:before { content: @fa-var-twitter; }\r\n.@{fa-css-prefix}-facebook-f:before,\r\n.@{fa-css-prefix}-facebook:before { content: @fa-var-facebook; }\r\n.@{fa-css-prefix}-github:before { content: @fa-var-github; }\r\n.@{fa-css-prefix}-unlock:before { content: @fa-var-unlock; }\r\n.@{fa-css-prefix}-credit-card:before { content: @fa-var-credit-card; }\r\n.@{fa-css-prefix}-rss:before { content: @fa-var-rss; }\r\n.@{fa-css-prefix}-hdd-o:before { content: @fa-var-hdd-o; }\r\n.@{fa-css-prefix}-bullhorn:before { content: @fa-var-bullhorn; }\r\n.@{fa-css-prefix}-bell:before { content: @fa-var-bell; }\r\n.@{fa-css-prefix}-certificate:before { content: @fa-var-certificate; }\r\n.@{fa-css-prefix}-hand-o-right:before { content: @fa-var-hand-o-right; }\r\n.@{fa-css-prefix}-hand-o-left:before { content: @fa-var-hand-o-left; }\r\n.@{fa-css-prefix}-hand-o-up:before { content: @fa-var-hand-o-up; }\r\n.@{fa-css-prefix}-hand-o-down:before { content: @fa-var-hand-o-down; }\r\n.@{fa-css-prefix}-arrow-circle-left:before { content: @fa-var-arrow-circle-left; }\r\n.@{fa-css-prefix}-arrow-circle-right:before { content: @fa-var-arrow-circle-right; }\r\n.@{fa-css-prefix}-arrow-circle-up:before { content: @fa-var-arrow-circle-up; }\r\n.@{fa-css-prefix}-arrow-circle-down:before { content: @fa-var-arrow-circle-down; }\r\n.@{fa-css-prefix}-globe:before { content: @fa-var-globe; }\r\n.@{fa-css-prefix}-wrench:before { content: @fa-var-wrench; }\r\n.@{fa-css-prefix}-tasks:before { content: @fa-var-tasks; }\r\n.@{fa-css-prefix}-filter:before { content: @fa-var-filter; }\r\n.@{fa-css-prefix}-briefcase:before { content: @fa-var-briefcase; }\r\n.@{fa-css-prefix}-arrows-alt:before { content: @fa-var-arrows-alt; }\r\n.@{fa-css-prefix}-group:before,\r\n.@{fa-css-prefix}-users:before { content: @fa-var-users; }\r\n.@{fa-css-prefix}-chain:before,\r\n.@{fa-css-prefix}-link:before { content: @fa-var-link; }\r\n.@{fa-css-prefix}-cloud:before { content: @fa-var-cloud; }\r\n.@{fa-css-prefix}-flask:before { content: @fa-var-flask; }\r\n.@{fa-css-prefix}-cut:before,\r\n.@{fa-css-prefix}-scissors:before { content: @fa-var-scissors; }\r\n.@{fa-css-prefix}-copy:before,\r\n.@{fa-css-prefix}-files-o:before { content: @fa-var-files-o; }\r\n.@{fa-css-prefix}-paperclip:before { content: @fa-var-paperclip; }\r\n.@{fa-css-prefix}-save:before,\r\n.@{fa-css-prefix}-floppy-o:before { content: @fa-var-floppy-o; }\r\n.@{fa-css-prefix}-square:before { content: @fa-var-square; }\r\n.@{fa-css-prefix}-navicon:before,\r\n.@{fa-css-prefix}-reorder:before,\r\n.@{fa-css-prefix}-bars:before { content: @fa-var-bars; }\r\n.@{fa-css-prefix}-list-ul:before { content: @fa-var-list-ul; }\r\n.@{fa-css-prefix}-list-ol:before { content: @fa-var-list-ol; }\r\n.@{fa-css-prefix}-strikethrough:before { content: @fa-var-strikethrough; }\r\n.@{fa-css-prefix}-underline:before { content: @fa-var-underline; }\r\n.@{fa-css-prefix}-table:before { content: @fa-var-table; }\r\n.@{fa-css-prefix}-magic:before { content: @fa-var-magic; }\r\n.@{fa-css-prefix}-truck:before { content: @fa-var-truck; }\r\n.@{fa-css-prefix}-pinterest:before { content: @fa-var-pinterest; }\r\n.@{fa-css-prefix}-pinterest-square:before { content: @fa-var-pinterest-square; }\r\n.@{fa-css-prefix}-google-plus-square:before { content: @fa-var-google-plus-square; }\r\n.@{fa-css-prefix}-google-plus:before { content: @fa-var-google-plus; }\r\n.@{fa-css-prefix}-money:before { content: @fa-var-money; }\r\n.@{fa-css-prefix}-caret-down:before { content: @fa-var-caret-down; }\r\n.@{fa-css-prefix}-caret-up:before { content: @fa-var-caret-up; }\r\n.@{fa-css-prefix}-caret-left:before { content: @fa-var-caret-left; }\r\n.@{fa-css-prefix}-caret-right:before { content: @fa-var-caret-right; }\r\n.@{fa-css-prefix}-columns:before { content: @fa-var-columns; }\r\n.@{fa-css-prefix}-unsorted:before,\r\n.@{fa-css-prefix}-sort:before { content: @fa-var-sort; }\r\n.@{fa-css-prefix}-sort-down:before,\r\n.@{fa-css-prefix}-sort-desc:before { content: @fa-var-sort-desc; }\r\n.@{fa-css-prefix}-sort-up:before,\r\n.@{fa-css-prefix}-sort-asc:before { content: @fa-var-sort-asc; }\r\n.@{fa-css-prefix}-envelope:before { content: @fa-var-envelope; }\r\n.@{fa-css-prefix}-linkedin:before { content: @fa-var-linkedin; }\r\n.@{fa-css-prefix}-rotate-left:before,\r\n.@{fa-css-prefix}-undo:before { content: @fa-var-undo; }\r\n.@{fa-css-prefix}-legal:before,\r\n.@{fa-css-prefix}-gavel:before { content: @fa-var-gavel; }\r\n.@{fa-css-prefix}-dashboard:before,\r\n.@{fa-css-prefix}-tachometer:before { content: @fa-var-tachometer; }\r\n.@{fa-css-prefix}-comment-o:before { content: @fa-var-comment-o; }\r\n.@{fa-css-prefix}-comments-o:before { content: @fa-var-comments-o; }\r\n.@{fa-css-prefix}-flash:before,\r\n.@{fa-css-prefix}-bolt:before { content: @fa-var-bolt; }\r\n.@{fa-css-prefix}-sitemap:before { content: @fa-var-sitemap; }\r\n.@{fa-css-prefix}-umbrella:before { content: @fa-var-umbrella; }\r\n.@{fa-css-prefix}-paste:before,\r\n.@{fa-css-prefix}-clipboard:before { content: @fa-var-clipboard; }\r\n.@{fa-css-prefix}-lightbulb-o:before { content: @fa-var-lightbulb-o; }\r\n.@{fa-css-prefix}-exchange:before { content: @fa-var-exchange; }\r\n.@{fa-css-prefix}-cloud-download:before { content: @fa-var-cloud-download; }\r\n.@{fa-css-prefix}-cloud-upload:before { content: @fa-var-cloud-upload; }\r\n.@{fa-css-prefix}-user-md:before { content: @fa-var-user-md; }\r\n.@{fa-css-prefix}-stethoscope:before { content: @fa-var-stethoscope; }\r\n.@{fa-css-prefix}-suitcase:before { content: @fa-var-suitcase; }\r\n.@{fa-css-prefix}-bell-o:before { content: @fa-var-bell-o; }\r\n.@{fa-css-prefix}-coffee:before { content: @fa-var-coffee; }\r\n.@{fa-css-prefix}-cutlery:before { content: @fa-var-cutlery; }\r\n.@{fa-css-prefix}-file-text-o:before { content: @fa-var-file-text-o; }\r\n.@{fa-css-prefix}-building-o:before { content: @fa-var-building-o; }\r\n.@{fa-css-prefix}-hospital-o:before { content: @fa-var-hospital-o; }\r\n.@{fa-css-prefix}-ambulance:before { content: @fa-var-ambulance; }\r\n.@{fa-css-prefix}-medkit:before { content: @fa-var-medkit; }\r\n.@{fa-css-prefix}-fighter-jet:before { content: @fa-var-fighter-jet; }\r\n.@{fa-css-prefix}-beer:before { content: @fa-var-beer; }\r\n.@{fa-css-prefix}-h-square:before { content: @fa-var-h-square; }\r\n.@{fa-css-prefix}-plus-square:before { content: @fa-var-plus-square; }\r\n.@{fa-css-prefix}-angle-double-left:before { content: @fa-var-angle-double-left; }\r\n.@{fa-css-prefix}-angle-double-right:before { content: @fa-var-angle-double-right; }\r\n.@{fa-css-prefix}-angle-double-up:before { content: @fa-var-angle-double-up; }\r\n.@{fa-css-prefix}-angle-double-down:before { content: @fa-var-angle-double-down; }\r\n.@{fa-css-prefix}-angle-left:before { content: @fa-var-angle-left; }\r\n.@{fa-css-prefix}-angle-right:before { content: @fa-var-angle-right; }\r\n.@{fa-css-prefix}-angle-up:before { content: @fa-var-angle-up; }\r\n.@{fa-css-prefix}-angle-down:before { content: @fa-var-angle-down; }\r\n.@{fa-css-prefix}-desktop:before { content: @fa-var-desktop; }\r\n.@{fa-css-prefix}-laptop:before { content: @fa-var-laptop; }\r\n.@{fa-css-prefix}-tablet:before { content: @fa-var-tablet; }\r\n.@{fa-css-prefix}-mobile-phone:before,\r\n.@{fa-css-prefix}-mobile:before { content: @fa-var-mobile; }\r\n.@{fa-css-prefix}-circle-o:before { content: @fa-var-circle-o; }\r\n.@{fa-css-prefix}-quote-left:before { content: @fa-var-quote-left; }\r\n.@{fa-css-prefix}-quote-right:before { content: @fa-var-quote-right; }\r\n.@{fa-css-prefix}-spinner:before { content: @fa-var-spinner; }\r\n.@{fa-css-prefix}-circle:before { content: @fa-var-circle; }\r\n.@{fa-css-prefix}-mail-reply:before,\r\n.@{fa-css-prefix}-reply:before { content: @fa-var-reply; }\r\n.@{fa-css-prefix}-github-alt:before { content: @fa-var-github-alt; }\r\n.@{fa-css-prefix}-folder-o:before { content: @fa-var-folder-o; }\r\n.@{fa-css-prefix}-folder-open-o:before { content: @fa-var-folder-open-o; }\r\n.@{fa-css-prefix}-smile-o:before { content: @fa-var-smile-o; }\r\n.@{fa-css-prefix}-frown-o:before { content: @fa-var-frown-o; }\r\n.@{fa-css-prefix}-meh-o:before { content: @fa-var-meh-o; }\r\n.@{fa-css-prefix}-gamepad:before { content: @fa-var-gamepad; }\r\n.@{fa-css-prefix}-keyboard-o:before { content: @fa-var-keyboard-o; }\r\n.@{fa-css-prefix}-flag-o:before { content: @fa-var-flag-o; }\r\n.@{fa-css-prefix}-flag-checkered:before { content: @fa-var-flag-checkered; }\r\n.@{fa-css-prefix}-terminal:before { content: @fa-var-terminal; }\r\n.@{fa-css-prefix}-code:before { content: @fa-var-code; }\r\n.@{fa-css-prefix}-mail-reply-all:before,\r\n.@{fa-css-prefix}-reply-all:before { content: @fa-var-reply-all; }\r\n.@{fa-css-prefix}-star-half-empty:before,\r\n.@{fa-css-prefix}-star-half-full:before,\r\n.@{fa-css-prefix}-star-half-o:before { content: @fa-var-star-half-o; }\r\n.@{fa-css-prefix}-location-arrow:before { content: @fa-var-location-arrow; }\r\n.@{fa-css-prefix}-crop:before { content: @fa-var-crop; }\r\n.@{fa-css-prefix}-code-fork:before { content: @fa-var-code-fork; }\r\n.@{fa-css-prefix}-unlink:before,\r\n.@{fa-css-prefix}-chain-broken:before { content: @fa-var-chain-broken; }\r\n.@{fa-css-prefix}-question:before { content: @fa-var-question; }\r\n.@{fa-css-prefix}-info:before { content: @fa-var-info; }\r\n.@{fa-css-prefix}-exclamation:before { content: @fa-var-exclamation; }\r\n.@{fa-css-prefix}-superscript:before { content: @fa-var-superscript; }\r\n.@{fa-css-prefix}-subscript:before { content: @fa-var-subscript; }\r\n.@{fa-css-prefix}-eraser:before { content: @fa-var-eraser; }\r\n.@{fa-css-prefix}-puzzle-piece:before { content: @fa-var-puzzle-piece; }\r\n.@{fa-css-prefix}-microphone:before { content: @fa-var-microphone; }\r\n.@{fa-css-prefix}-microphone-slash:before { content: @fa-var-microphone-slash; }\r\n.@{fa-css-prefix}-shield:before { content: @fa-var-shield; }\r\n.@{fa-css-prefix}-calendar-o:before { content: @fa-var-calendar-o; }\r\n.@{fa-css-prefix}-fire-extinguisher:before { content: @fa-var-fire-extinguisher; }\r\n.@{fa-css-prefix}-rocket:before { content: @fa-var-rocket; }\r\n.@{fa-css-prefix}-maxcdn:before { content: @fa-var-maxcdn; }\r\n.@{fa-css-prefix}-chevron-circle-left:before { content: @fa-var-chevron-circle-left; }\r\n.@{fa-css-prefix}-chevron-circle-right:before { content: @fa-var-chevron-circle-right; }\r\n.@{fa-css-prefix}-chevron-circle-up:before { content: @fa-var-chevron-circle-up; }\r\n.@{fa-css-prefix}-chevron-circle-down:before { content: @fa-var-chevron-circle-down; }\r\n.@{fa-css-prefix}-html5:before { content: @fa-var-html5; }\r\n.@{fa-css-prefix}-css3:before { content: @fa-var-css3; }\r\n.@{fa-css-prefix}-anchor:before { content: @fa-var-anchor; }\r\n.@{fa-css-prefix}-unlock-alt:before { content: @fa-var-unlock-alt; }\r\n.@{fa-css-prefix}-bullseye:before { content: @fa-var-bullseye; }\r\n.@{fa-css-prefix}-ellipsis-h:before { content: @fa-var-ellipsis-h; }\r\n.@{fa-css-prefix}-ellipsis-v:before { content: @fa-var-ellipsis-v; }\r\n.@{fa-css-prefix}-rss-square:before { content: @fa-var-rss-square; }\r\n.@{fa-css-prefix}-play-circle:before { content: @fa-var-play-circle; }\r\n.@{fa-css-prefix}-ticket:before { content: @fa-var-ticket; }\r\n.@{fa-css-prefix}-minus-square:before { content: @fa-var-minus-square; }\r\n.@{fa-css-prefix}-minus-square-o:before { content: @fa-var-minus-square-o; }\r\n.@{fa-css-prefix}-level-up:before { content: @fa-var-level-up; }\r\n.@{fa-css-prefix}-level-down:before { content: @fa-var-level-down; }\r\n.@{fa-css-prefix}-check-square:before { content: @fa-var-check-square; }\r\n.@{fa-css-prefix}-pencil-square:before { content: @fa-var-pencil-square; }\r\n.@{fa-css-prefix}-external-link-square:before { content: @fa-var-external-link-square; }\r\n.@{fa-css-prefix}-share-square:before { content: @fa-var-share-square; }\r\n.@{fa-css-prefix}-compass:before { content: @fa-var-compass; }\r\n.@{fa-css-prefix}-toggle-down:before,\r\n.@{fa-css-prefix}-caret-square-o-down:before { content: @fa-var-caret-square-o-down; }\r\n.@{fa-css-prefix}-toggle-up:before,\r\n.@{fa-css-prefix}-caret-square-o-up:before { content: @fa-var-caret-square-o-up; }\r\n.@{fa-css-prefix}-toggle-right:before,\r\n.@{fa-css-prefix}-caret-square-o-right:before { content: @fa-var-caret-square-o-right; }\r\n.@{fa-css-prefix}-euro:before,\r\n.@{fa-css-prefix}-eur:before { content: @fa-var-eur; }\r\n.@{fa-css-prefix}-gbp:before { content: @fa-var-gbp; }\r\n.@{fa-css-prefix}-dollar:before,\r\n.@{fa-css-prefix}-usd:before { content: @fa-var-usd; }\r\n.@{fa-css-prefix}-rupee:before,\r\n.@{fa-css-prefix}-inr:before { content: @fa-var-inr; }\r\n.@{fa-css-prefix}-cny:before,\r\n.@{fa-css-prefix}-rmb:before,\r\n.@{fa-css-prefix}-yen:before,\r\n.@{fa-css-prefix}-jpy:before { content: @fa-var-jpy; }\r\n.@{fa-css-prefix}-ruble:before,\r\n.@{fa-css-prefix}-rouble:before,\r\n.@{fa-css-prefix}-rub:before { content: @fa-var-rub; }\r\n.@{fa-css-prefix}-won:before,\r\n.@{fa-css-prefix}-krw:before { content: @fa-var-krw; }\r\n.@{fa-css-prefix}-bitcoin:before,\r\n.@{fa-css-prefix}-btc:before { content: @fa-var-btc; }\r\n.@{fa-css-prefix}-file:before { content: @fa-var-file; }\r\n.@{fa-css-prefix}-file-text:before { content: @fa-var-file-text; }\r\n.@{fa-css-prefix}-sort-alpha-asc:before { content: @fa-var-sort-alpha-asc; }\r\n.@{fa-css-prefix}-sort-alpha-desc:before { content: @fa-var-sort-alpha-desc; }\r\n.@{fa-css-prefix}-sort-amount-asc:before { content: @fa-var-sort-amount-asc; }\r\n.@{fa-css-prefix}-sort-amount-desc:before { content: @fa-var-sort-amount-desc; }\r\n.@{fa-css-prefix}-sort-numeric-asc:before { content: @fa-var-sort-numeric-asc; }\r\n.@{fa-css-prefix}-sort-numeric-desc:before { content: @fa-var-sort-numeric-desc; }\r\n.@{fa-css-prefix}-thumbs-up:before { content: @fa-var-thumbs-up; }\r\n.@{fa-css-prefix}-thumbs-down:before { content: @fa-var-thumbs-down; }\r\n.@{fa-css-prefix}-youtube-square:before { content: @fa-var-youtube-square; }\r\n.@{fa-css-prefix}-youtube:before { content: @fa-var-youtube; }\r\n.@{fa-css-prefix}-xing:before { content: @fa-var-xing; }\r\n.@{fa-css-prefix}-xing-square:before { content: @fa-var-xing-square; }\r\n.@{fa-css-prefix}-youtube-play:before { content: @fa-var-youtube-play; }\r\n.@{fa-css-prefix}-dropbox:before { content: @fa-var-dropbox; }\r\n.@{fa-css-prefix}-stack-overflow:before { content: @fa-var-stack-overflow; }\r\n.@{fa-css-prefix}-instagram:before { content: @fa-var-instagram; }\r\n.@{fa-css-prefix}-flickr:before { content: @fa-var-flickr; }\r\n.@{fa-css-prefix}-adn:before { content: @fa-var-adn; }\r\n.@{fa-css-prefix}-bitbucket:before { content: @fa-var-bitbucket; }\r\n.@{fa-css-prefix}-bitbucket-square:before { content: @fa-var-bitbucket-square; }\r\n.@{fa-css-prefix}-tumblr:before { content: @fa-var-tumblr; }\r\n.@{fa-css-prefix}-tumblr-square:before { content: @fa-var-tumblr-square; }\r\n.@{fa-css-prefix}-long-arrow-down:before { content: @fa-var-long-arrow-down; }\r\n.@{fa-css-prefix}-long-arrow-up:before { content: @fa-var-long-arrow-up; }\r\n.@{fa-css-prefix}-long-arrow-left:before { content: @fa-var-long-arrow-left; }\r\n.@{fa-css-prefix}-long-arrow-right:before { content: @fa-var-long-arrow-right; }\r\n.@{fa-css-prefix}-apple:before { content: @fa-var-apple; }\r\n.@{fa-css-prefix}-windows:before { content: @fa-var-windows; }\r\n.@{fa-css-prefix}-android:before { content: @fa-var-android; }\r\n.@{fa-css-prefix}-linux:before { content: @fa-var-linux; }\r\n.@{fa-css-prefix}-dribbble:before { content: @fa-var-dribbble; }\r\n.@{fa-css-prefix}-skype:before { content: @fa-var-skype; }\r\n.@{fa-css-prefix}-foursquare:before { content: @fa-var-foursquare; }\r\n.@{fa-css-prefix}-trello:before { content: @fa-var-trello; }\r\n.@{fa-css-prefix}-female:before { content: @fa-var-female; }\r\n.@{fa-css-prefix}-male:before { content: @fa-var-male; }\r\n.@{fa-css-prefix}-gittip:before,\r\n.@{fa-css-prefix}-gratipay:before { content: @fa-var-gratipay; }\r\n.@{fa-css-prefix}-sun-o:before { content: @fa-var-sun-o; }\r\n.@{fa-css-prefix}-moon-o:before { content: @fa-var-moon-o; }\r\n.@{fa-css-prefix}-archive:before { content: @fa-var-archive; }\r\n.@{fa-css-prefix}-bug:before { content: @fa-var-bug; }\r\n.@{fa-css-prefix}-vk:before { content: @fa-var-vk; }\r\n.@{fa-css-prefix}-weibo:before { content: @fa-var-weibo; }\r\n.@{fa-css-prefix}-renren:before { content: @fa-var-renren; }\r\n.@{fa-css-prefix}-pagelines:before { content: @fa-var-pagelines; }\r\n.@{fa-css-prefix}-stack-exchange:before { content: @fa-var-stack-exchange; }\r\n.@{fa-css-prefix}-arrow-circle-o-right:before { content: @fa-var-arrow-circle-o-right; }\r\n.@{fa-css-prefix}-arrow-circle-o-left:before { content: @fa-var-arrow-circle-o-left; }\r\n.@{fa-css-prefix}-toggle-left:before,\r\n.@{fa-css-prefix}-caret-square-o-left:before { content: @fa-var-caret-square-o-left; }\r\n.@{fa-css-prefix}-dot-circle-o:before { content: @fa-var-dot-circle-o; }\r\n.@{fa-css-prefix}-wheelchair:before { content: @fa-var-wheelchair; }\r\n.@{fa-css-prefix}-vimeo-square:before { content: @fa-var-vimeo-square; }\r\n.@{fa-css-prefix}-turkish-lira:before,\r\n.@{fa-css-prefix}-try:before { content: @fa-var-try; }\r\n.@{fa-css-prefix}-plus-square-o:before { content: @fa-var-plus-square-o; }\r\n.@{fa-css-prefix}-space-shuttle:before { content: @fa-var-space-shuttle; }\r\n.@{fa-css-prefix}-slack:before { content: @fa-var-slack; }\r\n.@{fa-css-prefix}-envelope-square:before { content: @fa-var-envelope-square; }\r\n.@{fa-css-prefix}-wordpress:before { content: @fa-var-wordpress; }\r\n.@{fa-css-prefix}-openid:before { content: @fa-var-openid; }\r\n.@{fa-css-prefix}-institution:before,\r\n.@{fa-css-prefix}-bank:before,\r\n.@{fa-css-prefix}-university:before { content: @fa-var-university; }\r\n.@{fa-css-prefix}-mortar-board:before,\r\n.@{fa-css-prefix}-graduation-cap:before { content: @fa-var-graduation-cap; }\r\n.@{fa-css-prefix}-yahoo:before { content: @fa-var-yahoo; }\r\n.@{fa-css-prefix}-google:before { content: @fa-var-google; }\r\n.@{fa-css-prefix}-reddit:before { content: @fa-var-reddit; }\r\n.@{fa-css-prefix}-reddit-square:before { content: @fa-var-reddit-square; }\r\n.@{fa-css-prefix}-stumbleupon-circle:before { content: @fa-var-stumbleupon-circle; }\r\n.@{fa-css-prefix}-stumbleupon:before { content: @fa-var-stumbleupon; }\r\n.@{fa-css-prefix}-delicious:before { content: @fa-var-delicious; }\r\n.@{fa-css-prefix}-digg:before { content: @fa-var-digg; }\r\n.@{fa-css-prefix}-pied-piper:before { content: @fa-var-pied-piper; }\r\n.@{fa-css-prefix}-pied-piper-alt:before { content: @fa-var-pied-piper-alt; }\r\n.@{fa-css-prefix}-drupal:before { content: @fa-var-drupal; }\r\n.@{fa-css-prefix}-joomla:before { content: @fa-var-joomla; }\r\n.@{fa-css-prefix}-language:before { content: @fa-var-language; }\r\n.@{fa-css-prefix}-fax:before { content: @fa-var-fax; }\r\n.@{fa-css-prefix}-building:before { content: @fa-var-building; }\r\n.@{fa-css-prefix}-child:before { content: @fa-var-child; }\r\n.@{fa-css-prefix}-paw:before { content: @fa-var-paw; }\r\n.@{fa-css-prefix}-spoon:before { content: @fa-var-spoon; }\r\n.@{fa-css-prefix}-cube:before { content: @fa-var-cube; }\r\n.@{fa-css-prefix}-cubes:before { content: @fa-var-cubes; }\r\n.@{fa-css-prefix}-behance:before { content: @fa-var-behance; }\r\n.@{fa-css-prefix}-behance-square:before { content: @fa-var-behance-square; }\r\n.@{fa-css-prefix}-steam:before { content: @fa-var-steam; }\r\n.@{fa-css-prefix}-steam-square:before { content: @fa-var-steam-square; }\r\n.@{fa-css-prefix}-recycle:before { content: @fa-var-recycle; }\r\n.@{fa-css-prefix}-automobile:before,\r\n.@{fa-css-prefix}-car:before { content: @fa-var-car; }\r\n.@{fa-css-prefix}-cab:before,\r\n.@{fa-css-prefix}-taxi:before { content: @fa-var-taxi; }\r\n.@{fa-css-prefix}-tree:before { content: @fa-var-tree; }\r\n.@{fa-css-prefix}-spotify:before { content: @fa-var-spotify; }\r\n.@{fa-css-prefix}-deviantart:before { content: @fa-var-deviantart; }\r\n.@{fa-css-prefix}-soundcloud:before { content: @fa-var-soundcloud; }\r\n.@{fa-css-prefix}-database:before { content: @fa-var-database; }\r\n.@{fa-css-prefix}-file-pdf-o:before { content: @fa-var-file-pdf-o; }\r\n.@{fa-css-prefix}-file-word-o:before { content: @fa-var-file-word-o; }\r\n.@{fa-css-prefix}-file-excel-o:before { content: @fa-var-file-excel-o; }\r\n.@{fa-css-prefix}-file-powerpoint-o:before { content: @fa-var-file-powerpoint-o; }\r\n.@{fa-css-prefix}-file-photo-o:before,\r\n.@{fa-css-prefix}-file-picture-o:before,\r\n.@{fa-css-prefix}-file-image-o:before { content: @fa-var-file-image-o; }\r\n.@{fa-css-prefix}-file-zip-o:before,\r\n.@{fa-css-prefix}-file-archive-o:before { content: @fa-var-file-archive-o; }\r\n.@{fa-css-prefix}-file-sound-o:before,\r\n.@{fa-css-prefix}-file-audio-o:before { content: @fa-var-file-audio-o; }\r\n.@{fa-css-prefix}-file-movie-o:before,\r\n.@{fa-css-prefix}-file-video-o:before { content: @fa-var-file-video-o; }\r\n.@{fa-css-prefix}-file-code-o:before { content: @fa-var-file-code-o; }\r\n.@{fa-css-prefix}-vine:before { content: @fa-var-vine; }\r\n.@{fa-css-prefix}-codepen:before { content: @fa-var-codepen; }\r\n.@{fa-css-prefix}-jsfiddle:before { content: @fa-var-jsfiddle; }\r\n.@{fa-css-prefix}-life-bouy:before,\r\n.@{fa-css-prefix}-life-buoy:before,\r\n.@{fa-css-prefix}-life-saver:before,\r\n.@{fa-css-prefix}-support:before,\r\n.@{fa-css-prefix}-life-ring:before { content: @fa-var-life-ring; }\r\n.@{fa-css-prefix}-circle-o-notch:before { content: @fa-var-circle-o-notch; }\r\n.@{fa-css-prefix}-ra:before,\r\n.@{fa-css-prefix}-rebel:before { content: @fa-var-rebel; }\r\n.@{fa-css-prefix}-ge:before,\r\n.@{fa-css-prefix}-empire:before { content: @fa-var-empire; }\r\n.@{fa-css-prefix}-git-square:before { content: @fa-var-git-square; }\r\n.@{fa-css-prefix}-git:before { content: @fa-var-git; }\r\n.@{fa-css-prefix}-hacker-news:before { content: @fa-var-hacker-news; }\r\n.@{fa-css-prefix}-tencent-weibo:before { content: @fa-var-tencent-weibo; }\r\n.@{fa-css-prefix}-qq:before { content: @fa-var-qq; }\r\n.@{fa-css-prefix}-wechat:before,\r\n.@{fa-css-prefix}-weixin:before { content: @fa-var-weixin; }\r\n.@{fa-css-prefix}-send:before,\r\n.@{fa-css-prefix}-paper-plane:before { content: @fa-var-paper-plane; }\r\n.@{fa-css-prefix}-send-o:before,\r\n.@{fa-css-prefix}-paper-plane-o:before { content: @fa-var-paper-plane-o; }\r\n.@{fa-css-prefix}-history:before { content: @fa-var-history; }\r\n.@{fa-css-prefix}-genderless:before,\r\n.@{fa-css-prefix}-circle-thin:before { content: @fa-var-circle-thin; }\r\n.@{fa-css-prefix}-header:before { content: @fa-var-header; }\r\n.@{fa-css-prefix}-paragraph:before { content: @fa-var-paragraph; }\r\n.@{fa-css-prefix}-sliders:before { content: @fa-var-sliders; }\r\n.@{fa-css-prefix}-share-alt:before { content: @fa-var-share-alt; }\r\n.@{fa-css-prefix}-share-alt-square:before { content: @fa-var-share-alt-square; }\r\n.@{fa-css-prefix}-bomb:before { content: @fa-var-bomb; }\r\n.@{fa-css-prefix}-soccer-ball-o:before,\r\n.@{fa-css-prefix}-futbol-o:before { content: @fa-var-futbol-o; }\r\n.@{fa-css-prefix}-tty:before { content: @fa-var-tty; }\r\n.@{fa-css-prefix}-binoculars:before { content: @fa-var-binoculars; }\r\n.@{fa-css-prefix}-plug:before { content: @fa-var-plug; }\r\n.@{fa-css-prefix}-slideshare:before { content: @fa-var-slideshare; }\r\n.@{fa-css-prefix}-twitch:before { content: @fa-var-twitch; }\r\n.@{fa-css-prefix}-yelp:before { content: @fa-var-yelp; }\r\n.@{fa-css-prefix}-newspaper-o:before { content: @fa-var-newspaper-o; }\r\n.@{fa-css-prefix}-wifi:before { content: @fa-var-wifi; }\r\n.@{fa-css-prefix}-calculator:before { content: @fa-var-calculator; }\r\n.@{fa-css-prefix}-paypal:before { content: @fa-var-paypal; }\r\n.@{fa-css-prefix}-google-wallet:before { content: @fa-var-google-wallet; }\r\n.@{fa-css-prefix}-cc-visa:before { content: @fa-var-cc-visa; }\r\n.@{fa-css-prefix}-cc-mastercard:before { content: @fa-var-cc-mastercard; }\r\n.@{fa-css-prefix}-cc-discover:before { content: @fa-var-cc-discover; }\r\n.@{fa-css-prefix}-cc-amex:before { content: @fa-var-cc-amex; }\r\n.@{fa-css-prefix}-cc-paypal:before { content: @fa-var-cc-paypal; }\r\n.@{fa-css-prefix}-cc-stripe:before { content: @fa-var-cc-stripe; }\r\n.@{fa-css-prefix}-bell-slash:before { content: @fa-var-bell-slash; }\r\n.@{fa-css-prefix}-bell-slash-o:before { content: @fa-var-bell-slash-o; }\r\n.@{fa-css-prefix}-trash:before { content: @fa-var-trash; }\r\n.@{fa-css-prefix}-copyright:before { content: @fa-var-copyright; }\r\n.@{fa-css-prefix}-at:before { content: @fa-var-at; }\r\n.@{fa-css-prefix}-eyedropper:before { content: @fa-var-eyedropper; }\r\n.@{fa-css-prefix}-paint-brush:before { content: @fa-var-paint-brush; }\r\n.@{fa-css-prefix}-birthday-cake:before { content: @fa-var-birthday-cake; }\r\n.@{fa-css-prefix}-area-chart:before { content: @fa-var-area-chart; }\r\n.@{fa-css-prefix}-pie-chart:before { content: @fa-var-pie-chart; }\r\n.@{fa-css-prefix}-line-chart:before { content: @fa-var-line-chart; }\r\n.@{fa-css-prefix}-lastfm:before { content: @fa-var-lastfm; }\r\n.@{fa-css-prefix}-lastfm-square:before { content: @fa-var-lastfm-square; }\r\n.@{fa-css-prefix}-toggle-off:before { content: @fa-var-toggle-off; }\r\n.@{fa-css-prefix}-toggle-on:before { content: @fa-var-toggle-on; }\r\n.@{fa-css-prefix}-bicycle:before { content: @fa-var-bicycle; }\r\n.@{fa-css-prefix}-bus:before { content: @fa-var-bus; }\r\n.@{fa-css-prefix}-ioxhost:before { content: @fa-var-ioxhost; }\r\n.@{fa-css-prefix}-angellist:before { content: @fa-var-angellist; }\r\n.@{fa-css-prefix}-cc:before { content: @fa-var-cc; }\r\n.@{fa-css-prefix}-shekel:before,\r\n.@{fa-css-prefix}-sheqel:before,\r\n.@{fa-css-prefix}-ils:before { content: @fa-var-ils; }\r\n.@{fa-css-prefix}-meanpath:before { content: @fa-var-meanpath; }\r\n.@{fa-css-prefix}-buysellads:before { content: @fa-var-buysellads; }\r\n.@{fa-css-prefix}-connectdevelop:before { content: @fa-var-connectdevelop; }\r\n.@{fa-css-prefix}-dashcube:before { content: @fa-var-dashcube; }\r\n.@{fa-css-prefix}-forumbee:before { content: @fa-var-forumbee; }\r\n.@{fa-css-prefix}-leanpub:before { content: @fa-var-leanpub; }\r\n.@{fa-css-prefix}-sellsy:before { content: @fa-var-sellsy; }\r\n.@{fa-css-prefix}-shirtsinbulk:before { content: @fa-var-shirtsinbulk; }\r\n.@{fa-css-prefix}-simplybuilt:before { content: @fa-var-simplybuilt; }\r\n.@{fa-css-prefix}-skyatlas:before { content: @fa-var-skyatlas; }\r\n.@{fa-css-prefix}-cart-plus:before { content: @fa-var-cart-plus; }\r\n.@{fa-css-prefix}-cart-arrow-down:before { content: @fa-var-cart-arrow-down; }\r\n.@{fa-css-prefix}-diamond:before { content: @fa-var-diamond; }\r\n.@{fa-css-prefix}-ship:before { content: @fa-var-ship; }\r\n.@{fa-css-prefix}-user-secret:before { content: @fa-var-user-secret; }\r\n.@{fa-css-prefix}-motorcycle:before { content: @fa-var-motorcycle; }\r\n.@{fa-css-prefix}-street-view:before { content: @fa-var-street-view; }\r\n.@{fa-css-prefix}-heartbeat:before { content: @fa-var-heartbeat; }\r\n.@{fa-css-prefix}-venus:before { content: @fa-var-venus; }\r\n.@{fa-css-prefix}-mars:before { content: @fa-var-mars; }\r\n.@{fa-css-prefix}-mercury:before { content: @fa-var-mercury; }\r\n.@{fa-css-prefix}-transgender:before { content: @fa-var-transgender; }\r\n.@{fa-css-prefix}-transgender-alt:before { content: @fa-var-transgender-alt; }\r\n.@{fa-css-prefix}-venus-double:before { content: @fa-var-venus-double; }\r\n.@{fa-css-prefix}-mars-double:before { content: @fa-var-mars-double; }\r\n.@{fa-css-prefix}-venus-mars:before { content: @fa-var-venus-mars; }\r\n.@{fa-css-prefix}-mars-stroke:before { content: @fa-var-mars-stroke; }\r\n.@{fa-css-prefix}-mars-stroke-v:before { content: @fa-var-mars-stroke-v; }\r\n.@{fa-css-prefix}-mars-stroke-h:before { content: @fa-var-mars-stroke-h; }\r\n.@{fa-css-prefix}-neuter:before { content: @fa-var-neuter; }\r\n.@{fa-css-prefix}-facebook-official:before { content: @fa-var-facebook-official; }\r\n.@{fa-css-prefix}-pinterest-p:before { content: @fa-var-pinterest-p; }\r\n.@{fa-css-prefix}-whatsapp:before { content: @fa-var-whatsapp; }\r\n.@{fa-css-prefix}-server:before { content: @fa-var-server; }\r\n.@{fa-css-prefix}-user-plus:before { content: @fa-var-user-plus; }\r\n.@{fa-css-prefix}-user-times:before { content: @fa-var-user-times; }\r\n.@{fa-css-prefix}-hotel:before,\r\n.@{fa-css-prefix}-bed:before { content: @fa-var-bed; }\r\n.@{fa-css-prefix}-viacoin:before { content: @fa-var-viacoin; }\r\n.@{fa-css-prefix}-train:before { content: @fa-var-train; }\r\n.@{fa-css-prefix}-subway:before { content: @fa-var-subway; }\r\n.@{fa-css-prefix}-medium:before { content: @fa-var-medium; }\r\n"],"sourceRoot":"/source/"} */ \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Styles/admin-dialog.css b/src/Orchard.Web/Modules/Orchard.Layouts/Styles/admin-dialog.css index ef66b3302..fb974363f 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Styles/admin-dialog.css +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Styles/admin-dialog.css @@ -75,7 +75,8 @@ header, footer, aside, nav, article { display: block; } } .zone-content .edit-widget .primary .widget-props, -.zone-content .edit-widget .secondary { +.zone-content .edit-widget .secondary, +.zone-content .edit-item .edit-item-secondary { display: none; } diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/ViewModels/LayoutEditor.cs b/src/Orchard.Web/Modules/Orchard.Layouts/ViewModels/LayoutEditor.cs index aafe067be..7c698de89 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/ViewModels/LayoutEditor.cs +++ b/src/Orchard.Web/Modules/Orchard.Layouts/ViewModels/LayoutEditor.cs @@ -7,7 +7,7 @@ namespace Orchard.Layouts.ViewModels { public IContent Content { get; set; } public string Data { get; set; } public string ConfigurationData { get; set; } - public string Trash { get; set; } + public string RecycleBin { get; set; } public int? TemplateId { get; set; } public string SessionKey { get; set; } public IList Templates { get; set; } diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/ViewModels/PlaceableContentItemViewModel.cs b/src/Orchard.Web/Modules/Orchard.Layouts/ViewModels/PlaceableContentItemViewModel.cs new file mode 100644 index 000000000..2445def98 --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Layouts/ViewModels/PlaceableContentItemViewModel.cs @@ -0,0 +1,5 @@ +namespace Orchard.Layouts.ViewModels { + public class PlaceableContentItemViewModel { + public int? ContentItemId { get; set; } + } +} \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Views/DefinitionTemplates/ContentPartLayoutSettings.cshtml b/src/Orchard.Web/Modules/Orchard.Layouts/Views/DefinitionTemplates/ContentPartLayoutSettings.cshtml index 9b9117ab3..755ac3a3b 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Views/DefinitionTemplates/ContentPartLayoutSettings.cshtml +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Views/DefinitionTemplates/ContentPartLayoutSettings.cshtml @@ -1,8 +1,4 @@ @model Orchard.Layouts.Settings.ContentPartLayoutSettings -@{ - Script.Require("jQuery"); - Script.Include("contentpart-layouts-settings.js"); -}
@Html.CheckBoxFor(m => m.Placeable) diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Views/DefinitionTemplates/ContentTypeLayoutSettings.cshtml b/src/Orchard.Web/Modules/Orchard.Layouts/Views/DefinitionTemplates/ContentTypeLayoutSettings.cshtml new file mode 100644 index 000000000..3d6dd8cfb --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Views/DefinitionTemplates/ContentTypeLayoutSettings.cshtml @@ -0,0 +1,6 @@ +@model Orchard.Layouts.Settings.ContentTypeLayoutSettings +
+ @Html.CheckBoxFor(m => m.Placeable) + + @T("Check to allow this type to be placeable on a layout.") +
\ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Views/EditorTemplates/Elements.PlaceableContentItem.cshtml b/src/Orchard.Web/Modules/Orchard.Layouts/Views/EditorTemplates/Elements.PlaceableContentItem.cshtml new file mode 100644 index 000000000..9c55c19e3 --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Views/EditorTemplates/Elements.PlaceableContentItem.cshtml @@ -0,0 +1,2 @@ +@model Orchard.Layouts.ViewModels.PlaceableContentItemViewModel +@Html.HiddenFor(m => m.ContentItemId) \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Views/EditorTemplates/LayoutEditor.cshtml b/src/Orchard.Web/Modules/Orchard.Layouts/Views/EditorTemplates/LayoutEditor.cshtml index 77da2ebe4..728150bc7 100644 --- a/src/Orchard.Web/Modules/Orchard.Layouts/Views/EditorTemplates/LayoutEditor.cshtml +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Views/EditorTemplates/LayoutEditor.cshtml @@ -66,6 +66,7 @@ @Html.HiddenFor(m => m.SessionKey) @Html.HiddenFor(m => m.Data, new { @class = "layout-data-field" }) + @Html.HiddenFor(m => m.RecycleBin, new { @class = "recycle-bin-data-field" })
  1. diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Views/Elements/PlaceableContentItem.Design.cshtml b/src/Orchard.Web/Modules/Orchard.Layouts/Views/Elements/PlaceableContentItem.Design.cshtml new file mode 100644 index 000000000..e558b56f8 --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Views/Elements/PlaceableContentItem.Design.cshtml @@ -0,0 +1,12 @@ +@using Orchard.ContentManagement +@{ + var contentItem = (ContentItem)Model.ContentItem; +} +
    + @if (contentItem != null) { + @String.Format("{0} - {1}", Html.ItemDisplayText(contentItem), contentItem.TypeDefinition.DisplayName) + } + else { + @T("Content Item Not Found"); + } +
    \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Layouts/Views/Elements/PlaceableContentItem.cshtml b/src/Orchard.Web/Modules/Orchard.Layouts/Views/Elements/PlaceableContentItem.cshtml new file mode 100644 index 000000000..1ec56cf21 --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Layouts/Views/Elements/PlaceableContentItem.cshtml @@ -0,0 +1,9 @@ +@using Orchard.Layouts.Helpers +@{ + var tagBuilder = TagBuilderExtensions.CreateElementTagBuilder(Model); +} +@tagBuilder.StartElement +@if (Model.ContentShape != null) { + @Display(Model.ContentShape) +} +@tagBuilder.EndElement \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Widgets/Conditions/ContentDisplayedRuleProvider.cs b/src/Orchard.Web/Modules/Orchard.Widgets/Conditions/ContentDisplayedRuleProvider.cs new file mode 100644 index 000000000..ea53d8563 --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Widgets/Conditions/ContentDisplayedRuleProvider.cs @@ -0,0 +1,23 @@ +using System; +using Orchard.Conditions.Services; +using Orchard.Widgets.Handlers; + +namespace Orchard.Widgets.Conditions { + public class ContentDisplayedRuleProvider : IConditionProvider { + private readonly IDisplayedContentItemHandler _displayedContentItemHandler; + + public ContentDisplayedRuleProvider(IDisplayedContentItemHandler displayedContentItemHandler) { + _displayedContentItemHandler = displayedContentItemHandler; + } + + public void Evaluate(ConditionEvaluationContext evaluationContext) { + if (!String.Equals(evaluationContext.FunctionName, "contenttype", StringComparison.OrdinalIgnoreCase)) { + return; + } + + var contentType = Convert.ToString(evaluationContext.Arguments[0]); + + evaluationContext.Result = _displayedContentItemHandler.IsDisplayed(contentType); + } + } +} \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Widgets/Drivers/LayerPartDriver.cs b/src/Orchard.Web/Modules/Orchard.Widgets/Drivers/LayerPartDriver.cs index 202ea2692..c0cc0c2a7 100644 --- a/src/Orchard.Web/Modules/Orchard.Widgets/Drivers/LayerPartDriver.cs +++ b/src/Orchard.Web/Modules/Orchard.Widgets/Drivers/LayerPartDriver.cs @@ -1,6 +1,7 @@ using System; using System.Collections.Generic; using System.Linq; +using Orchard.Conditions.Services; using Orchard.ContentManagement; using Orchard.ContentManagement.Drivers; using Orchard.ContentManagement.Handlers; @@ -11,14 +12,14 @@ using Orchard.Widgets.Services; namespace Orchard.Widgets.Drivers { public class LayerPartDriver : ContentPartDriver { - private readonly IRuleManager _ruleManager; + private readonly IConditionManager _conditionManager; private readonly IWidgetsService _widgetsService; public LayerPartDriver( - IRuleManager ruleManager, + IConditionManager conditionManager, IWidgetsService widgetsService) { - _ruleManager = ruleManager; + _conditionManager = conditionManager; _widgetsService = widgetsService; T = NullLocalizer.Instance; @@ -53,7 +54,7 @@ namespace Orchard.Widgets.Drivers { } try { - _ruleManager.Matches(layerPart.LayerRule); + _conditionManager.Matches(layerPart.LayerRule); } catch (Exception e) { updater.AddModelError("Description", T("The rule is not valid: {0}", e.Message)); diff --git a/src/Orchard.Web/Modules/Orchard.Widgets/Handlers/WidgetElementsHandler.cs b/src/Orchard.Web/Modules/Orchard.Widgets/Handlers/WidgetElementsHandler.cs new file mode 100644 index 000000000..92d6ed4b1 --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Widgets/Handlers/WidgetElementsHandler.cs @@ -0,0 +1,34 @@ +using Orchard.ContentManagement; +using Orchard.ContentManagement.Aspects; +using Orchard.ContentManagement.Handlers; +using Orchard.Environment.Extensions; +using Orchard.Layouts.Helpers; +using Orchard.Widgets.Models; + +namespace Orchard.Widgets.Handlers { + [OrchardFeature("Orchard.Widgets.Elements")] + public class WidgetElementsHandler : ContentHandler { + private readonly IOrchardServices _orchardServices; + + public WidgetElementsHandler(IOrchardServices orchardServices) { + _orchardServices = orchardServices; + OnUpdated(PostProcessPlacedWidget); + } + + private void PostProcessPlacedWidget(UpdateContentContext context, WidgetPart part) { + if (!part.IsPlaceableContent()) + return; + + // This is a widget placed on a layout, so clear out the zone propertiey + // to prevent the widget from appearing on the Widgets screen and on the front-end. + part.Zone = null; + + // To prevent the widget from being recognized as being orphaned, set its container. + // If the current container is a LayerPart, override that as well. + var commonPart = part.As(); + if (commonPart != null && (commonPart.Container == null || commonPart.Container.Is())) { + commonPart.Container = _orchardServices.WorkContext.CurrentSite; + } + } + } +} \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Widgets/Layouts/Elements/Widget.cs b/src/Orchard.Web/Modules/Orchard.Widgets/Layouts/Elements/Widget.cs new file mode 100644 index 000000000..ada221f17 --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Widgets/Layouts/Elements/Widget.cs @@ -0,0 +1,25 @@ +using Orchard.Environment.Extensions; +using Orchard.Layouts.Framework.Elements; +using Orchard.Layouts.Helpers; + +namespace Orchard.Widgets.Layouts.Elements { + [OrchardFeature("Orchard.Widgets.Elements")] + public class Widget : Element { + public override string Category { + get { return "Widgets"; } + } + + public override bool IsSystemElement { + get { return true; } + } + + public override bool HasEditor { + get { return false; } + } + + public int? WidgetId { + get { return this.Retrieve(x => x.WidgetId); } + set { this.Store(x => x.WidgetId, value); } + } + } +} \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Widgets/Layouts/Providers/WidgetElementHarvester.cs b/src/Orchard.Web/Modules/Orchard.Widgets/Layouts/Providers/WidgetElementHarvester.cs new file mode 100644 index 000000000..b5578837a --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Widgets/Layouts/Providers/WidgetElementHarvester.cs @@ -0,0 +1,176 @@ +using System; +using System.Collections.Generic; +using System.Linq; +using Orchard.ContentManagement; +using Orchard.ContentManagement.Aspects; +using Orchard.ContentManagement.MetaData.Models; +using Orchard.Core.Contents.Settings; +using Orchard.Environment; +using Orchard.Environment.Extensions; +using Orchard.Layouts.Framework.Display; +using Orchard.Layouts.Framework.Drivers; +using Orchard.Layouts.Framework.Elements; +using Orchard.Layouts.Framework.Harvesters; +using Orchard.Layouts.Helpers; +using Orchard.Widgets.Layouts.Elements; +using Orchard.Widgets.ViewModels; +using ContentItem = Orchard.ContentManagement.ContentItem; + +namespace Orchard.Widgets.Layouts.Providers { + [OrchardFeature("Orchard.Widgets.Elements")] + public class WidgetElementHarvester : Component, IElementHarvester { + private readonly Work _contentManager; + + public WidgetElementHarvester(Work contentManager) { + _contentManager = contentManager; + } + + public IEnumerable HarvestElements(HarvestElementsContext context) { + var contentTypeDefinitions = GetWidgetContentTypeDefinitions(); + + return contentTypeDefinitions.Select(contentTypeDefinition => { + var settings = contentTypeDefinition.Settings; + var description = settings.ContainsKey("Description") ? settings["Description"] : contentTypeDefinition.DisplayName; + return new ElementDescriptor(typeof (Widget), contentTypeDefinition.Name, T(contentTypeDefinition.DisplayName), T(description), category: "Widgets") { + Displaying = Displaying, + Editor = Editor, + UpdateEditor = UpdateEditor, + ToolboxIcon = "\uf1b2", + EnableEditorDialog = true, + Removing = RemoveContentItem, + Exporting = ExportElement, + Importing = ImportElement, + StateBag = new Dictionary { + { "ContentTypeName", contentTypeDefinition.Name } + } + }; + }); + } + + private void Displaying(ElementDisplayingContext context) { + var contentTypeName = (string)context.Element.Descriptor.StateBag["ContentTypeName"]; + var element = (Widget)context.Element; + var widgetId = element.WidgetId; + var versionOptions = context.DisplayType == "Design" ? VersionOptions.Latest : VersionOptions.Published; + var widget = widgetId != null + ? _contentManager.Value.Get(widgetId.Value, versionOptions) + : _contentManager.Value.New(contentTypeName); + + var widgetShape = widget != null ? _contentManager.Value.BuildDisplay(widget) : default(dynamic); + context.ElementShape.Widget = widget; + context.ElementShape.WidgetShape = widgetShape; + } + + private void Editor(ElementEditorContext context) { + UpdateEditor(context); + } + + private void UpdateEditor(ElementEditorContext context) { + var contentTypeName = (string)context.Element.Descriptor.StateBag["ContentTypeName"]; + var element = (Widget) context.Element; + var elementViewModel = new WidgetElementViewModel { + WidgetId = element.WidgetId + }; + + if (context.Updater != null) { + context.Updater.TryUpdateModel(elementViewModel, context.Prefix, null, null); + } + + var widgetId = elementViewModel.WidgetId; + var widget = widgetId != null + ? _contentManager.Value.Get(widgetId.Value, VersionOptions.Latest) + : _contentManager.Value.New(contentTypeName); + + dynamic contentEditorShape; + + if (context.Updater != null) { + if (widget.Id == 0) { + _contentManager.Value.Create(widget, VersionOptions.Draft); + } + else { + var isDraftable = widget.TypeDefinition.Settings.GetModel().Draftable; + var versionOptions = isDraftable ? VersionOptions.DraftRequired : VersionOptions.Latest; + widget = _contentManager.Value.Get(widget.Id, versionOptions); + } + + element.WidgetId = widget.Id; + + // If the widget has the CommonPart attached, set its Container property to the Content (if any). + // This helps preventing widgets from appearing as orphans. + var commonPart = widget.As(); + if (commonPart != null) + commonPart.Container = context.Content; + + widget.IsPlaceableContent(true); + contentEditorShape = _contentManager.Value.UpdateEditor(widget, context.Updater); + + _contentManager.Value.Publish(widget); + } + else { + contentEditorShape = _contentManager.Value.BuildEditor(widget); + } + + var elementEditorShape = context.ShapeFactory.EditorTemplate(TemplateName: "Elements.Widget", Model: elementViewModel, Prefix: context.Prefix); + + elementEditorShape.Metadata.Position = "Properties:0"; + contentEditorShape.Metadata.Position = "Properties:0"; + context.EditorResult.Add(elementEditorShape); + context.EditorResult.Add(contentEditorShape); + } + + private void RemoveContentItem(ElementRemovingContext context) { + var element = (Widget) context.Element; + var widgetId = element.WidgetId; + + // Only remove the widget if no other elements are referencing this one. + // This can happen if the user cut an element and then pasted it back. + // That will delete the initial element and create a copy. + var widgetElements = + from e in context.Elements.Flatten() + let p = e as Widget + where p != null && p.WidgetId == widgetId + select p; + + if (widgetElements.Any()) + return; + + var contentItem = widgetId != null ? _contentManager.Value.Get(widgetId.Value, VersionOptions.Latest) : default(ContentItem); + + if(contentItem != null) + _contentManager.Value.Remove(contentItem); + } + + private void ExportElement(ExportElementContext context) { + var element = (Widget)context.Element; + var widgetId = element.WidgetId; + var widget = widgetId != null ? _contentManager.Value.Get(widgetId.Value, VersionOptions.Latest) : default(ContentItem); + var widgetIdentity = widget != null ? _contentManager.Value.GetItemMetadata(widget).Identity.ToString() : default(string); + + if (widgetIdentity != null) + context.ExportableData["WidgetId"] = widgetIdentity; + } + + private void ImportElement(ImportElementContext context) { + var widgetIdentity = context.ExportableData.Get("WidgetId"); + + if (String.IsNullOrWhiteSpace(widgetIdentity)) + return; + + var widget = context.Session.GetItemFromSession(widgetIdentity); + var element = (Widget)context.Element; + + element.WidgetId = widget != null ? widget.Id : default(int?); + } + + private IEnumerable GetWidgetContentTypeDefinitions() { + // Select all types that have either "the "Widget" stereotype. + var contentTypeDefinitionsQuery = + from contentTypeDefinition in _contentManager.Value.GetContentTypeDefinitions() + let stereotype = contentTypeDefinition.Settings.ContainsKey("Stereotype") ? contentTypeDefinition.Settings["Stereotype"] : default(string) + where stereotype == "Widget" + select contentTypeDefinition; + + return contentTypeDefinitionsQuery.ToList(); + } + } +} \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Widgets/Models/WidgetPart.cs b/src/Orchard.Web/Modules/Orchard.Widgets/Models/WidgetPart.cs index 73d3a6525..aeb2805be 100644 --- a/src/Orchard.Web/Modules/Orchard.Widgets/Models/WidgetPart.cs +++ b/src/Orchard.Web/Modules/Orchard.Widgets/Models/WidgetPart.cs @@ -6,7 +6,7 @@ using Orchard.ContentManagement.Aspects; namespace Orchard.Widgets.Models { public class WidgetPart : ContentPart, ITitleAspect { - + /// /// The widget's title. /// @@ -25,7 +25,7 @@ namespace Orchard.Widgets.Models { } /// - /// Whether or not the Title should be rendered on the front-end + /// Whether or not the Title should be rendered on the front-end. /// public bool RenderTitle { get { return Retrieve(x => x.RenderTitle); } @@ -36,8 +36,7 @@ namespace Orchard.Widgets.Models { /// The widget's position within the zone. /// [Required] - public string Position - { + public string Position { get { return Retrieve(x => x.Position); } set { Store(x => x.Position, value); } } @@ -61,8 +60,11 @@ namespace Orchard.Widgets.Models { /// /// The layerPart identifier. /// - public int LayerId { - get { return this.As().Container.As().Id; } + public int? LayerId { + get { + var layerPart = LayerPart; + return layerPart != null ? layerPart.Id : default(int?); + } } /// diff --git a/src/Orchard.Web/Modules/Orchard.Widgets/Module.txt b/src/Orchard.Web/Modules/Orchard.Widgets/Module.txt index 1a0eb5338..3a8da5e14 100644 --- a/src/Orchard.Web/Modules/Orchard.Widgets/Module.txt +++ b/src/Orchard.Web/Modules/Orchard.Widgets/Module.txt @@ -7,7 +7,7 @@ OrchardVersion: 1.9 Description: An implementation of widgets for Orchard. FeatureDescription: An implementation of widgets. Category: Widget -Dependencies: Orchard.Scripting, Orchard.Themes +Dependencies: Orchard.Conditions, Orchard.Scripting, Orchard.Themes Features: Orchard.Widgets.PageLayerHinting: Name: Page Layer Hinting @@ -19,3 +19,8 @@ Features: Description: Add an Edit button on the front-end for authenticated users Category: Widget Dependencies: Orchard.Widgets + Orchard.Widgets.Elements + Name: Widget Elements + Description: Enables widgets to be added as elements to layouts. + Category: Layout + Dependencies: Orchard.Layouts \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Widgets/Orchard.Widgets.csproj b/src/Orchard.Web/Modules/Orchard.Widgets/Orchard.Widgets.csproj index d1aaa153a..a4c7a2837 100644 --- a/src/Orchard.Web/Modules/Orchard.Widgets/Orchard.Widgets.csproj +++ b/src/Orchard.Web/Modules/Orchard.Widgets/Orchard.Widgets.csproj @@ -26,6 +26,7 @@ + true @@ -74,6 +75,9 @@ + + + @@ -85,11 +89,8 @@ - - - - - + + @@ -99,12 +100,14 @@ + + @@ -131,6 +134,14 @@ Orchard.Framework True + + {98251eae-a41b-47b2-aa91-e28b8482da70} + Orchard.Conditions + + + {6bd8b2fa-f2e3-4ac8-a4c3-2925a653889a} + Orchard.Layouts + {99002B65-86F7-415E-BF4A-381AA8AB9CCC} Orchard.Scripting @@ -192,6 +203,20 @@ + + + + + + + + + + + + Designer + + 10.0 $(MSBuildExtensionsPath32)\Microsoft\VisualStudio\v$(VisualStudioVersion) diff --git a/src/Orchard.Web/Modules/Orchard.Widgets/RuleEngine/AuthenticatedRuleProvider.cs b/src/Orchard.Web/Modules/Orchard.Widgets/RuleEngine/AuthenticatedRuleProvider.cs deleted file mode 100644 index 085f37bbf..000000000 --- a/src/Orchard.Web/Modules/Orchard.Widgets/RuleEngine/AuthenticatedRuleProvider.cs +++ /dev/null @@ -1,26 +0,0 @@ -using System; -using Orchard.Security; -using Orchard.Widgets.Services; - -namespace Orchard.Widgets.RuleEngine { - public class AuthenticatedRuleProvider : IRuleProvider { - private readonly IAuthenticationService _authenticationService; - - public AuthenticatedRuleProvider(IAuthenticationService authenticationService) { - _authenticationService = authenticationService; - } - - public void Process(RuleContext ruleContext) { - if (!String.Equals(ruleContext.FunctionName, "authenticated", StringComparison.OrdinalIgnoreCase)) { - return; - } - - if (_authenticationService.GetAuthenticatedUser() != null) { - ruleContext.Result = true; - return; - } - - ruleContext.Result = false; - } - } -} \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Widgets/RuleEngine/BuiltinRuleProvider.cs b/src/Orchard.Web/Modules/Orchard.Widgets/RuleEngine/BuiltinRuleProvider.cs deleted file mode 100644 index c91ad04b3..000000000 --- a/src/Orchard.Web/Modules/Orchard.Widgets/RuleEngine/BuiltinRuleProvider.cs +++ /dev/null @@ -1,18 +0,0 @@ -using System; -using Orchard.Widgets.Services; - -namespace Orchard.Widgets.RuleEngine { - public class BuiltinRuleProvider : IRuleProvider { - private readonly IWorkContextAccessor _workContextAccessor; - - public BuiltinRuleProvider(IWorkContextAccessor workContextAccessor) { - _workContextAccessor = workContextAccessor; - } - - public void Process(RuleContext ruleContext) { - if (string.Equals(ruleContext.FunctionName, "WorkContext", StringComparison.OrdinalIgnoreCase)) { - ruleContext.Result = _workContextAccessor.GetContext(); - } - } - } -} \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Widgets/RuleEngine/ContentDisplayedRuleProvider.cs b/src/Orchard.Web/Modules/Orchard.Widgets/RuleEngine/ContentDisplayedRuleProvider.cs deleted file mode 100644 index ee79b97de..000000000 --- a/src/Orchard.Web/Modules/Orchard.Widgets/RuleEngine/ContentDisplayedRuleProvider.cs +++ /dev/null @@ -1,23 +0,0 @@ -using System; -using Orchard.Widgets.Handlers; -using Orchard.Widgets.Services; - -namespace Orchard.Widgets.RuleEngine { - public class ContentDisplayedRuleProvider : IRuleProvider { - private readonly IDisplayedContentItemHandler _displayedContentItemHandler; - - public ContentDisplayedRuleProvider(IDisplayedContentItemHandler displayedContentItemHandler) { - _displayedContentItemHandler = displayedContentItemHandler; - } - - public void Process(RuleContext ruleContext) { - if (!String.Equals(ruleContext.FunctionName, "contenttype", StringComparison.OrdinalIgnoreCase)) { - return; - } - - var contentType = Convert.ToString(ruleContext.Arguments[0]); - - ruleContext.Result = _displayedContentItemHandler.IsDisplayed(contentType); - } - } -} \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Widgets/Scripts/Web.config b/src/Orchard.Web/Modules/Orchard.Widgets/Scripts/Web.config new file mode 100644 index 000000000..11135c337 --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Widgets/Scripts/Web.config @@ -0,0 +1,16 @@ + + + + + + + + + + + + + diff --git a/src/Orchard.Web/Modules/Orchard.Widgets/Scripts/widget-element-editor.js b/src/Orchard.Web/Modules/Orchard.Widgets/Scripts/widget-element-editor.js new file mode 100644 index 000000000..32474bae5 --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Widgets/Scripts/widget-element-editor.js @@ -0,0 +1,9 @@ +(function ($) { + // Hide the Layer, Zone, and Position fieldsets and set a value for the required fields. + $(function() { + var fieldsets = $("#element-properties .edit-widget fieldset").slice(0, 3); + fieldsets.hide(); + + $("input[name='WidgetPart.Position']").val("0"); + }); +})(jQuery); \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Widgets/Services/DefaultLayerEvaluationService.cs b/src/Orchard.Web/Modules/Orchard.Widgets/Services/DefaultLayerEvaluationService.cs index 0ad3908f8..55b4a0682 100644 --- a/src/Orchard.Web/Modules/Orchard.Widgets/Services/DefaultLayerEvaluationService.cs +++ b/src/Orchard.Web/Modules/Orchard.Widgets/Services/DefaultLayerEvaluationService.cs @@ -1,5 +1,6 @@ using System; using System.Collections.Generic; +using Orchard.Conditions.Services; using Orchard.Localization; using Orchard.Logging; using Orchard.Widgets.Models; @@ -8,13 +9,13 @@ using Orchard.ContentManagement.Utilities; namespace Orchard.Widgets.Services{ public class DefaultLayerEvaluationService : ILayerEvaluationService { - private readonly IRuleManager _ruleManager; + private readonly IConditionManager _conditionManager; private readonly IOrchardServices _orchardServices; private readonly LazyField _activeLayerIDs; - public DefaultLayerEvaluationService(IRuleManager ruleManager, IOrchardServices orchardServices) { - _ruleManager = ruleManager; + public DefaultLayerEvaluationService(IConditionManager conditionManager, IOrchardServices orchardServices) { + _conditionManager = conditionManager; _orchardServices = orchardServices; Logger = NullLogger.Instance; @@ -38,7 +39,7 @@ namespace Orchard.Widgets.Services{ } private int[] PopulateActiveLayers() { - // Once the Rule Engine is done: + // Once the Condition Engine is done: // Get Layers and filter by zone and rule // NOTE: .ForType("Layer") is faster than .Query() var activeLayers = _orchardServices.ContentManager.Query().WithQueryHints(new QueryHints().ExpandParts()).ForType("Layer").List(); @@ -47,7 +48,7 @@ namespace Orchard.Widgets.Services{ foreach (var activeLayer in activeLayers) { // ignore the rule if it fails to execute try { - if (_ruleManager.Matches(activeLayer.LayerRule)) { + if (_conditionManager.Matches(activeLayer.LayerRule)) { activeLayerIds.Add(activeLayer.ContentItem.Id); } } diff --git a/src/Orchard.Web/Modules/Orchard.Widgets/Services/IRuleManager.cs b/src/Orchard.Web/Modules/Orchard.Widgets/Services/IRuleManager.cs index 38cdae2da..e0e9feafd 100644 --- a/src/Orchard.Web/Modules/Orchard.Widgets/Services/IRuleManager.cs +++ b/src/Orchard.Web/Modules/Orchard.Widgets/Services/IRuleManager.cs @@ -1,4 +1,7 @@ -namespace Orchard.Widgets.Services { +using System; + +namespace Orchard.Widgets.Services { + [Obsolete("Use Orchard.Conditions.Services.IConditionManager instead.")] public interface IRuleManager : IDependency { bool Matches(string expression); } diff --git a/src/Orchard.Web/Modules/Orchard.Widgets/Services/IRuleProvider.cs b/src/Orchard.Web/Modules/Orchard.Widgets/Services/IRuleProvider.cs index cd30e3f8c..4b5f87f2e 100644 --- a/src/Orchard.Web/Modules/Orchard.Widgets/Services/IRuleProvider.cs +++ b/src/Orchard.Web/Modules/Orchard.Widgets/Services/IRuleProvider.cs @@ -1,6 +1,8 @@ -using Orchard.Events; +using System; +using Orchard.Events; namespace Orchard.Widgets.Services { + [Obsolete("Use Orchard.Conditions.Services.IConditionProvider instead.")] public interface IRuleProvider : IEventHandler { void Process(RuleContext ruleContext); } diff --git a/src/Orchard.Web/Modules/Orchard.Widgets/Services/RuleContext.cs b/src/Orchard.Web/Modules/Orchard.Widgets/Services/RuleContext.cs index d1db6dea2..0d29400b9 100644 --- a/src/Orchard.Web/Modules/Orchard.Widgets/Services/RuleContext.cs +++ b/src/Orchard.Web/Modules/Orchard.Widgets/Services/RuleContext.cs @@ -1,4 +1,7 @@ -namespace Orchard.Widgets.Services { +using System; + +namespace Orchard.Widgets.Services { + [Obsolete("Use Orchard.Conditions.Services.ConditionEvaluationContext instead.")] public class RuleContext { public string FunctionName { get; set; } public object[] Arguments { get; set; } diff --git a/src/Orchard.Web/Modules/Orchard.Widgets/RuleEngine/RuleManager.cs b/src/Orchard.Web/Modules/Orchard.Widgets/Services/RuleManager.cs similarity index 91% rename from src/Orchard.Web/Modules/Orchard.Widgets/RuleEngine/RuleManager.cs rename to src/Orchard.Web/Modules/Orchard.Widgets/Services/RuleManager.cs index cba7bc5e6..927164b72 100644 --- a/src/Orchard.Web/Modules/Orchard.Widgets/RuleEngine/RuleManager.cs +++ b/src/Orchard.Web/Modules/Orchard.Widgets/Services/RuleManager.cs @@ -1,53 +1,54 @@ -using System.Collections.Generic; -using System.Linq; -using Orchard.Localization; -using Orchard.Scripting; -using Orchard.Widgets.Services; - -namespace Orchard.Widgets.RuleEngine { - public class RuleManager : IRuleManager { - private readonly IRuleProvider _ruleProviders; - private readonly IEnumerable _evaluators; - - public RuleManager(IRuleProvider ruleProviders, IEnumerable evaluators) { - _ruleProviders = ruleProviders; - _evaluators = evaluators; - T = NullLocalizer.Instance; - } - - public Localizer T { get; set; } - - public bool Matches(string expression) { - var evaluator = _evaluators.FirstOrDefault(); - if (evaluator == null) { - throw new OrchardException(T("There are currently no scripting engines enabled")); - } - - var result = evaluator.Evaluate(expression, new List { new GlobalMethodProvider(this) }); - if (!(result is bool)) { - throw new OrchardException(T("Expression is not a boolean value")); - } - return (bool)result; - } - - private class GlobalMethodProvider : IGlobalMethodProvider { - private readonly RuleManager _ruleManager; - - public GlobalMethodProvider(RuleManager ruleManager) { - _ruleManager = ruleManager; - } - - public void Process(GlobalMethodContext context) { - var ruleContext = new RuleContext { - FunctionName = context.FunctionName, - Arguments = context.Arguments.ToArray(), - Result = context.Result - }; - - _ruleManager._ruleProviders.Process(ruleContext); - - context.Result = ruleContext.Result; - } - } - } +using System; +using System.Collections.Generic; +using System.Linq; +using Orchard.Localization; +using Orchard.Scripting; + +namespace Orchard.Widgets.Services { + [Obsolete("Use Orchard.Conditions.Services.ConditionManager instead.")] + public class RuleManager : IRuleManager { + private readonly IRuleProvider _ruleProviders; + private readonly IEnumerable _evaluators; + + public RuleManager(IRuleProvider ruleProviders, IEnumerable evaluators) { + _ruleProviders = ruleProviders; + _evaluators = evaluators; + T = NullLocalizer.Instance; + } + + public Localizer T { get; set; } + + public bool Matches(string expression) { + var evaluator = _evaluators.FirstOrDefault(); + if (evaluator == null) { + throw new OrchardException(T("There are currently no scripting engines enabled")); + } + + var result = evaluator.Evaluate(expression, new List { new GlobalMethodProvider(this) }); + if (!(result is bool)) { + throw new OrchardException(T("Expression is not a boolean value")); + } + return (bool)result; + } + + private class GlobalMethodProvider : IGlobalMethodProvider { + private readonly RuleManager _ruleManager; + + public GlobalMethodProvider(RuleManager ruleManager) { + _ruleManager = ruleManager; + } + + public void Process(GlobalMethodContext context) { + var ruleContext = new RuleContext { + FunctionName = context.FunctionName, + Arguments = context.Arguments.ToArray(), + Result = context.Result + }; + + _ruleManager._ruleProviders.Process(ruleContext); + + context.Result = ruleContext.Result; + } + } + } } \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Widgets/ViewModels/WidgetElementViewModel.cs b/src/Orchard.Web/Modules/Orchard.Widgets/ViewModels/WidgetElementViewModel.cs new file mode 100644 index 000000000..74801cd64 --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Widgets/ViewModels/WidgetElementViewModel.cs @@ -0,0 +1,5 @@ +namespace Orchard.Widgets.ViewModels { + public class WidgetElementViewModel { + public int? WidgetId { get; set; } + } +} \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Widgets/Views/EditorTemplates/Elements.Widget.cshtml b/src/Orchard.Web/Modules/Orchard.Widgets/Views/EditorTemplates/Elements.Widget.cshtml new file mode 100644 index 000000000..8f25d7b64 --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Widgets/Views/EditorTemplates/Elements.Widget.cshtml @@ -0,0 +1,6 @@ +@model Orchard.Widgets.ViewModels.WidgetElementViewModel +@{ + Script.Require("jQuery"); + Script.Include("widget-element-editor.js"); +} +@Html.HiddenFor(m => m.WidgetId) \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Widgets/Views/EditorTemplates/Parts.Widgets.WidgetPart.cshtml b/src/Orchard.Web/Modules/Orchard.Widgets/Views/EditorTemplates/Parts.Widgets.WidgetPart.cshtml index 62a6ed3b0..30eb025f7 100644 --- a/src/Orchard.Web/Modules/Orchard.Widgets/Views/EditorTemplates/Parts.Widgets.WidgetPart.cshtml +++ b/src/Orchard.Web/Modules/Orchard.Widgets/Views/EditorTemplates/Parts.Widgets.WidgetPart.cshtml @@ -17,18 +17,18 @@
@Html.LabelFor(widget => widget.Title, T("Title")) - @Html.TextBoxFor(widget => widget.Title, new { @class = "text medium" }) + @Html.TextBoxFor(widget => widget.Title, new { @class = "text large" }) @T("The title of the Widget.") @Html.EditorFor(widget => widget.RenderTitle)
@Html.LabelFor(widget => widget.Name, T("Name")) - @Html.TextBoxFor(widget => widget.Name, new { @class = "text" }) + @Html.TextBoxFor(widget => widget.Name, new { @class = "text large" }) @T("The technical name of the Widget, used for css class and alternates.")
@Html.LabelFor(widget => widget.CssClasses, T("Css classes")) - @Html.TextBoxFor(widget => widget.CssClasses, new { @class = "text medium" }) + @Html.TextBoxFor(widget => widget.CssClasses, new { @class = "text large" }) @T("Add custom css classes for the widget separated by spaces.")
diff --git a/src/Orchard.Web/Modules/Orchard.Widgets/Views/Elements/Widget.Design.cshtml b/src/Orchard.Web/Modules/Orchard.Widgets/Views/Elements/Widget.Design.cshtml new file mode 100644 index 000000000..f109e9b73 --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Widgets/Views/Elements/Widget.Design.cshtml @@ -0,0 +1,12 @@ +@using Orchard.ContentManagement +@{ + var widget = (ContentItem)Model.Widget; +} +
+ @if (widget != null) { + @String.Format("{0} - {1}", Html.ItemDisplayText(widget), widget.TypeDefinition.DisplayName) + } + else { + @T("Widget Not Found"); + } +
\ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Widgets/Views/Elements/Widget.cshtml b/src/Orchard.Web/Modules/Orchard.Widgets/Views/Elements/Widget.cshtml new file mode 100644 index 000000000..d6ef13757 --- /dev/null +++ b/src/Orchard.Web/Modules/Orchard.Widgets/Views/Elements/Widget.cshtml @@ -0,0 +1,9 @@ +@using Orchard.Layouts.Helpers +@{ + var tagBuilder = TagBuilderExtensions.CreateElementTagBuilder(Model); +} +@tagBuilder.StartElement +@if (Model.WidgetShape != null) { + @Display(Model.WidgetShape) +} +@tagBuilder.EndElement \ No newline at end of file diff --git a/src/Orchard.Web/Modules/Orchard.Widgets/Views/WidgetPlacement.Orphans.cshtml b/src/Orchard.Web/Modules/Orchard.Widgets/Views/WidgetPlacement.Orphans.cshtml index a37ed0dca..5871e5798 100644 --- a/src/Orchard.Web/Modules/Orchard.Widgets/Views/WidgetPlacement.Orphans.cshtml +++ b/src/Orchard.Web/Modules/Orchard.Widgets/Views/WidgetPlacement.Orphans.cshtml @@ -7,7 +7,7 @@ } @if (widgets.Count() > 0) {
-

@T("Widgets with problems.")

+

@T("Widgets with problems")

@T("These widgets aren't going to appear anywhere because they're missing the CommonPart from their content type. To fix these widgets, if you still want to keep them around, start by fixing their Content Types.", Url.Action("Index", "Admin", new { area = "Orchard.ContentTypes" }))

    @foreach (WidgetPart widget in widgets) { diff --git a/src/Orchard.sln b/src/Orchard.sln index eff650fa4..6a8bed76d 100644 --- a/src/Orchard.sln +++ b/src/Orchard.sln @@ -270,6 +270,8 @@ Project("{2150E333-8FDC-42A3-9474-1A3956D46DE8}") = "Gulp", "Gulp", "{90EBEE36-B Package.json = Package.json EndProjectSection EndProject +Project("{FAE04EC0-301F-11D3-BF4B-00C04F79EFBC}") = "Orchard.Conditions", "Orchard.Web\Modules\Orchard.Conditions\Orchard.Conditions.csproj", "{98251EAE-A41B-47B2-AA91-E28B8482DA70}" +EndProject Global GlobalSection(SolutionConfigurationPlatforms) = preSolution CodeCoverage|Any CPU = CodeCoverage|Any CPU @@ -1082,6 +1084,13 @@ Global {BAC82DB9-F4C4-4DD1-ABDB-F70E6229E6B0}.FxCop|Any CPU.Build.0 = Release|Any CPU {BAC82DB9-F4C4-4DD1-ABDB-F70E6229E6B0}.Release|Any CPU.ActiveCfg = Release|Any CPU {BAC82DB9-F4C4-4DD1-ABDB-F70E6229E6B0}.Release|Any CPU.Build.0 = Release|Any CPU + {98251EAE-A41B-47B2-AA91-E28B8482DA70}.CodeCoverage|Any CPU.ActiveCfg = Release|Any CPU + {98251EAE-A41B-47B2-AA91-E28B8482DA70}.Coverage|Any CPU.ActiveCfg = Release|Any CPU + {98251EAE-A41B-47B2-AA91-E28B8482DA70}.Debug|Any CPU.ActiveCfg = Debug|Any CPU + {98251EAE-A41B-47B2-AA91-E28B8482DA70}.Debug|Any CPU.Build.0 = Debug|Any CPU + {98251EAE-A41B-47B2-AA91-E28B8482DA70}.FxCop|Any CPU.ActiveCfg = Release|Any CPU + {98251EAE-A41B-47B2-AA91-E28B8482DA70}.Release|Any CPU.ActiveCfg = Release|Any CPU + {98251EAE-A41B-47B2-AA91-E28B8482DA70}.Release|Any CPU.Build.0 = Release|Any CPU EndGlobalSection GlobalSection(SolutionProperties) = preSolution HideSolutionNode = FALSE @@ -1167,5 +1176,6 @@ Global {82190F52-2901-46D6-8A4C-34649959483F} = {E9C9F120-07BA-4DFB-B9C3-3AFB9D44C9D5} {BAC82DB9-F4C4-4DD1-ABDB-F70E6229E6B0} = {E9C9F120-07BA-4DFB-B9C3-3AFB9D44C9D5} {90EBEE36-B5CD-42A8-A21B-76270E2C5D24} = {DF3909B0-1DDD-4D8A-9919-56FC438E25E2} + {98251EAE-A41B-47B2-AA91-E28B8482DA70} = {E9C9F120-07BA-4DFB-B9C3-3AFB9D44C9D5} EndGlobalSection EndGlobal