diff --git a/src/Squidex.Domain.Apps.Core.Operations/Scripting/JintScriptEngine.cs b/src/Squidex.Domain.Apps.Core.Operations/Scripting/JintScriptEngine.cs
index 5e0772860..b9abcee99 100644
--- a/src/Squidex.Domain.Apps.Core.Operations/Scripting/JintScriptEngine.cs
+++ b/src/Squidex.Domain.Apps.Core.Operations/Scripting/JintScriptEngine.cs
@@ -115,7 +115,7 @@ namespace Squidex.Domain.Apps.Core.Scripting
             }
             catch (ParserException ex)
             {
-                throw new ValidationException("Failed to execute script with javascript syntaxs error.", new ValidationError(ex.Message));
+                throw new ValidationException("Failed to execute script with javascript syntax error.", new ValidationError(ex.Message));
             }
             catch (JavaScriptException ex)
             {
@@ -150,6 +150,7 @@ namespace Squidex.Domain.Apps.Core.Scripting
             }
 
             engine.SetValue("ctx", contextInstance);
+            engine.SetValue("slugify", new Func<string, string>(x => x.Slugify()));
 
             return engine;
         }
diff --git a/src/Squidex.Infrastructure.GetEventStore/EventSourcing/ProjectionHelper.cs b/src/Squidex.Infrastructure.GetEventStore/EventSourcing/ProjectionHelper.cs
index 3baccf1a2..4219dcdb0 100644
--- a/src/Squidex.Infrastructure.GetEventStore/EventSourcing/ProjectionHelper.cs
+++ b/src/Squidex.Infrastructure.GetEventStore/EventSourcing/ProjectionHelper.cs
@@ -25,7 +25,7 @@ namespace Squidex.Infrastructure.EventSourcing
 
         private static string ParseFilter(string prefix, string filter)
         {
-            return string.Format(CultureInfo.InvariantCulture, ProjectionName, prefix.Simplify(), filter.Simplify());
+            return string.Format(CultureInfo.InvariantCulture, ProjectionName, prefix.Slugify(), filter.Slugify());
         }
 
         public static async Task<string> CreateProjectionAsync(this IEventStoreConnection connection, ProjectionsManager projectionsManager, string prefix, string streamFilter = null)
diff --git a/src/Squidex.Infrastructure/StringExtensions.cs b/src/Squidex.Infrastructure/StringExtensions.cs
index 111d5ca6e..98cf38e9a 100644
--- a/src/Squidex.Infrastructure/StringExtensions.cs
+++ b/src/Squidex.Infrastructure/StringExtensions.cs
@@ -357,7 +357,7 @@ namespace Squidex.Infrastructure
             }
         }
 
-        public static string Simplify(this string value, ISet<char> preserveHash = null, bool singleCharDiactric = false, char separator = '-')
+        public static string Slugify(this string value, ISet<char> preserveHash = null, bool singleCharDiactric = false, char separator = '-')
         {
             var result = new StringBuilder(value.Length);
 
diff --git a/tests/Squidex.Domain.Apps.Core.Tests/Operations/Scripting/JintScriptEngineTests.cs b/tests/Squidex.Domain.Apps.Core.Tests/Operations/Scripting/JintScriptEngineTests.cs
index d8830524a..92fdaf1ea 100644
--- a/tests/Squidex.Domain.Apps.Core.Tests/Operations/Scripting/JintScriptEngineTests.cs
+++ b/tests/Squidex.Domain.Apps.Core.Tests/Operations/Scripting/JintScriptEngineTests.cs
@@ -138,6 +138,36 @@ namespace Squidex.Domain.Apps.Core.Operations.Scripting
             Assert.Equal(expected, result);
         }
 
+        [Fact]
+        public void Should_slugify_value()
+        {
+            var content =
+                new NamedContentData()
+                    .AddField("title",
+                        new ContentFieldData()
+                            .AddValue("iv", "Hello World"));
+
+            var expected =
+                new NamedContentData()
+                    .AddField("title",
+                        new ContentFieldData()
+                            .AddValue("iv", "Hello World"))
+                    .AddField("slug",
+                        new ContentFieldData()
+                            .AddValue("iv", "hello-world"));
+
+            var context = new ScriptContext { Data = content };
+
+            var result = scriptEngine.Transform(context, @"
+                var data = ctx.data;
+
+                data.slug = { iv: slugify(data.title.iv) };
+
+                replace(data);");
+
+            Assert.Equal(expected, result);
+        }
+
         [Fact]
         public void Should_transform_content_and_return_with_execute_transform()
         {
diff --git a/tests/Squidex.Infrastructure.Tests/StringExtensionsTests.cs b/tests/Squidex.Infrastructure.Tests/StringExtensionsTests.cs
index c7ebdf024..112a8c468 100644
--- a/tests/Squidex.Infrastructure.Tests/StringExtensionsTests.cs
+++ b/tests/Squidex.Infrastructure.Tests/StringExtensionsTests.cs
@@ -57,27 +57,27 @@ namespace Squidex.Infrastructure
         [InlineData("Hello World ", '_', "hello_world")]
         [InlineData("Hello World-", '_', "hello_world")]
         [InlineData("Hello/World_", '_', "hello_world")]
-        public void Should_replace_special_characters_with_sepator_when_simplifying(string input, char separator, string output)
+        public void Should_replace_special_characters_with_sepator_when_slugifying(string input, char separator, string output)
         {
-            Assert.Equal(output, input.Simplify(separator: separator));
+            Assert.Equal(output, input.Slugify(separator: separator));
         }
 
         [Theory]
         [InlineData("ö", "oe")]
         [InlineData("ü", "ue")]
         [InlineData("ä", "ae")]
-        public void Should_replace_multi_char_diacritics_when_simplifying(string input, string output)
+        public void Should_replace_multi_char_diacritics_when_slugifying(string input, string output)
         {
-            Assert.Equal(output, input.Simplify());
+            Assert.Equal(output, input.Slugify());
         }
 
         [Theory]
         [InlineData("ö", "o")]
         [InlineData("ü", "u")]
         [InlineData("ä", "a")]
-        public void Should_not_replace_multi_char_diacritics_when_simplifying(string input, string output)
+        public void Should_not_replace_multi_char_diacritics_when_slugifying(string input, string output)
         {
-            Assert.Equal(output, input.Simplify(singleCharDiactric: true));
+            Assert.Equal(output, input.Slugify(singleCharDiactric: true));
         }
 
         [Theory]
@@ -87,18 +87,18 @@ namespace Squidex.Infrastructure
         [InlineData("fórm", "form")]
         [InlineData("fòrm", "form")]
         [InlineData("fårt", "fart")]
-        public void Should_replace_single_char_diacritics_when_simplifying(string input, string output)
+        public void Should_replace_single_char_diacritics_when_slugifying(string input, string output)
         {
-            Assert.Equal(output, input.Simplify());
+            Assert.Equal(output, input.Slugify());
         }
 
         [Theory]
         [InlineData("Hello my&World ", '_', "hello_my&world")]
         [InlineData("Hello my&World-", '_', "hello_my&world")]
         [InlineData("Hello my/World_", '_', "hello_my/world")]
-        public void Should_keep_characters_when_simplifying(string input, char separator, string output)
+        public void Should_keep_characters_when_slugifying(string input, char separator, string output)
         {
-            Assert.Equal(output, input.Simplify(new HashSet<char> { '&', '/' }, false, separator));
+            Assert.Equal(output, input.Slugify(new HashSet<char> { '&', '/' }, false, separator));
         }
 
         [Fact]