diff --git a/picard/script/functions.py b/picard/script/functions.py
index b68454dee..9a0eae1f3 100644
--- a/picard/script/functions.py
+++ b/picard/script/functions.py
@@ -1386,20 +1386,18 @@ def func_countryname(parser, country_code, translate=""):
 DateTuple = namedtuple('DateTuple', ('year', 'month', 'day'))
 
 
-def _split_date(date_to_parse, date_order="ymd", separator="-"):
+def _split_date(date_to_parse, date_order="ymd"):
     """Split the specified date into parts.
 
     Args:
         date_to_parse (str): Date string to parse
         date_order (str, optional): Order of date elements. Can be "ymd", "mdy" or "dmy". Defaults to "ymd".
-        separator (str, optional): Separator between date parts. Defaults to "-".
 
     Returns:
         tuple: Tuple of the date parts as (year, month, day)
     """
-    if separator == '':
-        separator = None
-    parts = date_to_parse.strip().split(separator)
+
+    parts = re.split('[^0-9]+', date_to_parse.strip())
     parts.extend(['', '', ''])
     date_order = date_order.lower()
     if date_order == 'dmy':
@@ -1411,63 +1409,58 @@ def _split_date(date_to_parse, date_order="ymd", separator="-"):
 
 
 @script_function(documentation=N_(
-    """`$year(date,date_order="ymd",separator="-")`
+    """`$year(date,date_order="ymd")`
 
-Returns the year portion of the specified date.  The default order is "ymd" and the default separator is a hyphen.
-The default date order can be changed by specifying either "dmy" or "mdy".  The default separator can be changed by
-specifying a different character if required. If the date is invalid an empty string will be returned.
+Returns the year portion of the specified date.  The default order is "ymd".  This can be changed by specifying
+either "dmy" or "mdy".  If the date is invalid an empty string will be returned.
 """
 ))
-def func_year(parser, date_to_parse, date_order='ymd', separator="-"):
-    return _split_date(date_to_parse, date_order, separator).year
+def func_year(parser, date_to_parse, date_order='ymd'):
+    return _split_date(date_to_parse, date_order).year
 
 
 @script_function(documentation=N_(
-    """`$month(date,date_order="ymd",separator="-")`
+    """`$month(date,date_order="ymd")`
 
-Returns the month portion of the specified date.  The default order is "ymd" and the default separator is a hyphen.
-The default date order can be changed by specifying either "dmy" or "mdy".  The default separator can be changed by
-specifying a different character if required. If the date is invalid an empty string will be returned.
+Returns the month portion of the specified date.  The default order is "ymd".  This can be changed by specifying
+either "dmy" or "mdy".  If the date is invalid an empty string will be returned.
 """
 ))
-def func_month(parser, date_to_parse, date_order='ymd', separator="-"):
-    return _split_date(date_to_parse, date_order, separator).month
+def func_month(parser, date_to_parse, date_order='ymd'):
+    return _split_date(date_to_parse, date_order).month
 
 
 @script_function(documentation=N_(
-    """`$day(date,date_order="ymd",separator="-")`
+    """`$day(date,date_order="ymd")`
 
-Returns the day portion of the specified date.  The default order is "ymd" and the default separator is a hyphen.
-The default date order can be changed by specifying either "dmy" or "mdy".  The default separator can be changed by
-specifying a different character if required. If the date is invalid an empty string will be returned.
+Returns the day portion of the specified date.  The default order is "ymd".  This can be changed by specifying
+either "dmy" or "mdy".  If the date is invalid an empty string will be returned.
 """
 ))
-def func_day(parser, date_to_parse, date_order='ymd', separator="-"):
-    return _split_date(date_to_parse, date_order, separator).day
+def func_day(parser, date_to_parse, date_order='ymd'):
+    return _split_date(date_to_parse, date_order).day
 
 
 @script_function(documentation=N_(
-    """`$dateformat(date,format="%Y-%m-%d",date_order="ymd",separator="-")`
+    """`$dateformat(date,format="%Y-%m-%d",date_order="ymd")`
 
 Returns the input date in the specified `format`, which is based on the standard
     Python `strftime` [format codes](https://strftime.org/). If no `format` is
     specified the date will be returned in the form `2020-02-05`.
 
-    The default order for the input date is "ymd" and the default separator is a
-    hyphen.  The default date order can be changed by specifying either "dmy" or
-    "mdy".  The default separator can be changed by specifying a different character
-    if required.
+    The default order for the input date is "ymd".  This can be changed by specifying
+    either "dmy" or "mdy".
 Note: Platform-specific formatting codes should be avoided to help ensure the
     portability of scripts across the different platforms.  These codes include:
     remove zero-padding (e.g. `%-d` and `%-m` on Linux or macOS, and their
     equivalent `%#d` and `%#m` on Windows); element length specifiers (e.g.
     `%3Y`); and hanging '%' at the end of the format string."""
 ))
-def func_dateformat(parser, date_to_parse, date_format=None, date_order='ymd', separator="-"):
+def func_dateformat(parser, date_to_parse, date_format=None, date_order='ymd'):
     # Handle case where format evaluates to ''
     if not date_format:
         date_format = '%Y-%m-%d'
-    yr, mo, da = _split_date(date_to_parse, date_order, separator)
+    yr, mo, da = _split_date(date_to_parse, date_order)
     try:
         date_object = datetime.date(int(yr), int(mo), int(da))
     except ValueError:
diff --git a/test/test_script.py b/test/test_script.py
index a26c9c20a..a35743b52 100644
--- a/test/test_script.py
+++ b/test/test_script.py
@@ -1647,136 +1647,129 @@ class ScriptParserTest(PicardTestCase):
         context = Metadata()
         context["foo"] = "07.21.2021"
         context["bar"] = "mdy"
-        context["baz"] = "."
 
         # Test with default values
+        self.assertScriptResultEquals("$year(2021 07 21)", "2021", context)
+        self.assertScriptResultEquals("$year(2021.07.21)", "2021", context)
         self.assertScriptResultEquals("$year(2021-07-21)", "2021", context)
         self.assertScriptResultEquals("$year(21-07-21)", "21", context)
 
         # Test with overrides specified
-        self.assertScriptResultEquals("$year(%foo%,%bar%,%baz%)", "2021", context)
+        self.assertScriptResultEquals("$year(%foo%,%bar%)", "2021", context)
 
         # Test with invalid overrides
         self.assertScriptResultEquals("$year(2021-07-21,myd)", "2021", context)
-        self.assertScriptResultEquals("$year(2021-07-21,,.)", "2021-07-21", context)
-        self.assertScriptResultEquals("$year(2021-07-21,, )", "2021-07-21", context)
 
         # Test missing elements
         self.assertScriptResultEquals("$year(,)", "", context)
-        self.assertScriptResultEquals("$year(,,)", "", context)
         self.assertScriptResultEquals("$year(07-21,mdy)", "", context)
         self.assertScriptResultEquals("$year(21-07,dmy)", "", context)
 
         # Tests with invalid number of arguments
-        areg = r"^\d+:\d+:\$year: Wrong number of arguments for \$year: Expected between 1 and 3, "
+        areg = r"^\d+:\d+:\$year: Wrong number of arguments for \$year: Expected between 1 and 2, "
         with self.assertRaisesRegex(ScriptError, areg):
             self.parser.eval("$year()")
         with self.assertRaisesRegex(ScriptError, areg):
-            self.parser.eval("$year(2021-07-21,,,)")
+            self.parser.eval("$year(2021-07-21,,)")
 
     def test_cmd_month(self):
         context = Metadata()
         context["foo"] = "07.21.2021"
         context["bar"] = "mdy"
-        context["baz"] = "."
 
         # Test with default values
+        self.assertScriptResultEquals("$month(2021 07 21)", "07", context)
+        self.assertScriptResultEquals("$month(2021.07.21)", "07", context)
         self.assertScriptResultEquals("$month(2021-07-21)", "07", context)
         self.assertScriptResultEquals("$month(2021-7-21)", "7", context)
 
         # Test with overrides specified
-        self.assertScriptResultEquals("$month(%foo%,%bar%,%baz%)", "07", context)
+        self.assertScriptResultEquals("$month(%foo%,%bar%)", "07", context)
 
         # Test with invalid overrides
         self.assertScriptResultEquals("$month(2021-07-21,myd)", "07", context)
-        self.assertScriptResultEquals("$month(2021-07-21,,.)", "", context)
-        self.assertScriptResultEquals("$month(2021-07-21,mdy,.)", "2021-07-21", context)
-        self.assertScriptResultEquals("$month(2021-07-21,, )", "", context)
 
         # Test missing elements
         self.assertScriptResultEquals("$month(,)", "", context)
-        self.assertScriptResultEquals("$month(,,)", "", context)
         self.assertScriptResultEquals("$month(-21-2021,mdy)", "", context)
-        self.assertScriptResultEquals("$month(21--2021,dmy)", "", context)
+        # self.assertScriptResultEquals("$month(21--2021,dmy)", "", context)
 
         # Tests with invalid number of arguments
-        areg = r"^\d+:\d+:\$month: Wrong number of arguments for \$month: Expected between 1 and 3, "
+        areg = r"^\d+:\d+:\$month: Wrong number of arguments for \$month: Expected between 1 and 2, "
         with self.assertRaisesRegex(ScriptError, areg):
             self.parser.eval("$month()")
         with self.assertRaisesRegex(ScriptError, areg):
-            self.parser.eval("$month(2021-07-21,,,)")
+            self.parser.eval("$month(2021-07-21,,)")
 
     def test_cmd_day(self):
         context = Metadata()
         context["foo"] = "07.21.2021"
         context["bar"] = "mdy"
-        context["baz"] = "."
 
         # Test with default values
+        self.assertScriptResultEquals("$day(2021 07 21)", "21", context)
+        self.assertScriptResultEquals("$day(2021.07.21)", "21", context)
         self.assertScriptResultEquals("$day(2021-07-21)", "21", context)
         self.assertScriptResultEquals("$day(2021-07-2)", "2", context)
 
         # Test with overrides specified
-        self.assertScriptResultEquals("$day(%foo%,%bar%,%baz%)", "21", context)
+        self.assertScriptResultEquals("$day(%foo%,%bar%)", "21", context)
 
         # Test with invalid overrides
         self.assertScriptResultEquals("$day(2021-07-21,myd)", "21", context)
-        self.assertScriptResultEquals("$day(2021-07-21,,.)", "", context)
-        self.assertScriptResultEquals("$day(2021-07-21,dmy,.)", "2021-07-21", context)
-        self.assertScriptResultEquals("$day(2021-07-21,, )", "", context)
 
         # Test missing elements
         self.assertScriptResultEquals("$day(,)", "", context)
-        self.assertScriptResultEquals("$day(,,)", "", context)
         self.assertScriptResultEquals("$day(-07-2021,dmy)", "", context)
-        self.assertScriptResultEquals("$day(07--2021,mdy)", "", context)
+        # self.assertScriptResultEquals("$day(07--2021,mdy)", "", context)
 
         # Tests with invalid number of arguments
-        areg = r"^\d+:\d+:\$day: Wrong number of arguments for \$day: Expected between 1 and 3, "
+        areg = r"^\d+:\d+:\$day: Wrong number of arguments for \$day: Expected between 1 and 2, "
         with self.assertRaisesRegex(ScriptError, areg):
             self.parser.eval("$day()")
         with self.assertRaisesRegex(ScriptError, areg):
-            self.parser.eval("$day(2021-07-21,,,)")
+            self.parser.eval("$day(2021-07-21,,)")
 
     def test_cmd_dateformat(self):
         context = Metadata()
         context["foo"] = "07.21.2021"
         context["bar"] = "mdy"
-        context["baz"] = "."
         context["format"] = "%Y.%m.%d"
 
         # Test with default values
+        self.assertScriptResultEquals("$dateformat(2021 07 21)", "2021-07-21", context)
+        self.assertScriptResultEquals("$dateformat(2021.07.21)", "2021-07-21", context)
         self.assertScriptResultEquals("$dateformat(2021-07-21)", "2021-07-21", context)
         self.assertScriptResultEquals("$dateformat(2021-7-21)", "2021-07-21", context)
 
         # Test with overrides specified
-        self.assertScriptResultEquals("$dateformat(%foo%,%format%,%bar%,%baz%)", "2021.07.21", context)
+        self.assertScriptResultEquals("$dateformat(%foo%,%format%,%bar%)", "2021.07.21", context)
 
         # Test with invalid overrides
         self.assertScriptResultEquals("$dateformat(2021-07-21,,myd)", "2021-07-21", context)
         areg = r"^\d+:\d+:\$dateformat: Invalid date"
+        # with self.assertRaisesRegex(ScriptError, areg):
+        #     self.parser.eval("$dateformat(2021-07-21,,,.)")
         with self.assertRaisesRegex(ScriptError, areg):
-            self.parser.eval("$dateformat(2021-07-21,,,.)")
+            self.parser.eval("$dateformat(2021-07-21,,dmy)")
         with self.assertRaisesRegex(ScriptError, areg):
-            self.parser.eval("$dateformat(2021-07-21,,dmy,.)")
-        with self.assertRaisesRegex(ScriptError, areg):
-            self.parser.eval("$dateformat(2021-07-21,,, )")
+            self.parser.eval("$dateformat(2021-07-21,,mdy)")
         with self.assertRaisesRegex(ScriptError, areg):
             self.parser.eval("$dateformat(2021-July-21)")
         with self.assertRaisesRegex(ScriptError, areg):
             self.parser.eval("$dateformat(2021)")
         with self.assertRaisesRegex(ScriptError, areg):
             self.parser.eval("$dateformat(2021-07)")
-        with self.assertRaisesRegex(ScriptError, areg):
-            self.parser.eval("$dateformat(2021--21)")
+        # with self.assertRaisesRegex(ScriptError, areg):
+        #     self.parser.eval("$dateformat(2021--21)")
 
         # Test missing elements
         with self.assertRaisesRegex(ScriptError, areg):
             self.parser.eval("$dateformat(,)")
 
         # Tests with invalid number of arguments
-        areg = r"^\d+:\d+:\$dateformat: Wrong number of arguments for \$dateformat: Expected between 1 and 4, "
+        areg = r"^\d+:\d+:\$dateformat: Wrong number of arguments for \$dateformat: Expected between 1 and 3, "
         with self.assertRaisesRegex(ScriptError, areg):
             self.parser.eval("$dateformat()")
         with self.assertRaisesRegex(ScriptError, areg):
-            self.parser.eval("$dateformat(2021-07-21,,,,)")
+            self.parser.eval("$dateformat(2021-07-21,,,)")