bare-script 3.0.4 → 3.0.6

package/lib/library.js

@@ -1,13 +1,14 @@
 // Licensed under the MIT License
 // https://github.com/craigahobbs/bare-script/blob/main/LICENSE
 
+import {
+    ValueArgsError, valueArgsModel, valueArgsValidate, valueBoolean, valueCompare, valueIs, valueJSON,
+    valueParseDatetime, valueParseInteger, valueParseNumber, valueRoundNumber, valueString, valueType
+} from './value.js';
 import {
     addCalculatedField, aggregateData, filterData, joinData, parseCSV, sortData, topData, validateData
 } from './data.js';
 import {validateType, validateTypeModel} from 'schema-markdown/lib/schema.js';
-import {
-    valueBoolean, valueCompare, valueIs, valueJSON, valueParseDatetime, valueParseInteger, valueParseNumber, valueString, valueType
-} from './value.js';
 import {parseSchemaMarkdown} from 'schema-markdown/lib/parser.js';
 import {typeModel} from 'schema-markdown/lib/typeModel.js';
 
@@ -29,14 +30,15 @@ export const defaultMaxStatements = 1e9;
 // $doc: Create a copy of an array
 // $arg array: The array to copy
 // $return: The array copy
-function arrayCopy([array = null]) {
-    if (valueType(array) !== 'array') {
-        return null;
-    }
-
+function arrayCopy(args) {
+    const [array] = valueArgsValidate(arrayCopyArgs, args);
     return [...array];
 }
 
+const arrayCopyArgs = valueArgsModel([
+    {'name': 'array', 'type': 'array'}
+]);
+
 
 // $function: arrayExtend
 // $group: Array
@@ -44,15 +46,17 @@ function arrayCopy([array = null]) {
 // $arg array: The array to extend
 // $arg array2: The array to extend with
 // $return: The extended array
-function arrayExtend([array = null, array2 = null]) {
-    if (valueType(array) !== 'array' || valueType(array2) !== 'array') {
-        return null;
-    }
-
+function arrayExtend(args) {
+    const [array, array2] = valueArgsValidate(arrayExtendArgs, args);
     array.push(...array2);
     return array;
 }
 
+const arrayExtendArgs = valueArgsModel([
+    {'name': 'array', 'type': 'array'},
+    {'name': 'array2', 'type': 'array'}
+]);
+
 
 // $function: arrayGet
 // $group: Array
@@ -60,15 +64,20 @@ function arrayExtend([array = null, array2 = null]) {
 // $arg array: The array
 // $arg index: The array element's index
 // $return: The array element
-function arrayGet([array = null, index = null]) {
-    if (valueType(array) !== 'array' ||
-        valueType(index) !== 'number' || Math.floor(index) !== index || index < 0 || index >= array.length) {
-        return null;
+function arrayGet(args) {
+    const [array, index] = valueArgsValidate(arrayGetArgs, args);
+    if (index >= array.length) {
+        throw new ValueArgsError('index', index);
     }
 
     return array[index];
 }
 
+const arrayGetArgs = valueArgsModel([
+    {'name': 'array', 'type': 'array'},
+    {'name': 'index', 'type': 'number', 'integer': true, 'gte': 0}
+]);
+
 
 // $function: arrayIndexOf
 // $group: Array
@@ -77,23 +86,31 @@ function arrayGet([array = null, index = null]) {
 // $arg value: The value to find in the array, or a match function, f(value) -> bool
 // $arg index: Optional (default is 0). The index at which to start the search.
 // $return: The first index of the value in the array; -1 if not found.
-function arrayIndexOf([array = null, value = null, index = 0], options) {
-    if (valueType(array) !== 'array' ||
-        valueType(index) !== 'number' || Math.floor(index) !== index || index < 0 || index >= array.length) {
-        return -1;
+function arrayIndexOf(args, options) {
+    const [array, value, index] = valueArgsValidate(arrayIndexOfArgs, args, -1);
+    if (index >= array.length) {
+        throw new ValueArgsError('index', index, -1);
     }
 
+    // Value function?
     if (valueType(value) === 'function') {
         for (let ix = index; ix < array.length; ix += 1) {
             if (valueBoolean(value([array[ix]], options))) {
                 return ix;
             }
         }
+        return -1;
     }
 
     return array.indexOf(value, index);
 }
 
+const arrayIndexOfArgs = valueArgsModel([
+    {'name': 'array', 'type': 'array'},
+    {'name': 'value'},
+    {'name': 'index', 'type': 'number', 'default': 0, 'integer': true, 'gte': 0}
+]);
+
 
 // $function: arrayJoin
 // $group: Array
@@ -101,14 +118,16 @@ function arrayIndexOf([array = null, value = null, index = 0], options) {
 // $arg array: The array
 // $arg separator: The separator string
 // $return: The joined string
-function arrayJoin([array = null, separator = null]) {
-    if (valueType(array) !== 'array' || valueType(separator) !== 'string') {
-        return null;
-    }
-
+function arrayJoin(args) {
+    const [array , separator] = valueArgsValidate(arrayJoinArgs, args);
     return array.map((value) => valueString(value)).join(separator);
 }
 
+const arrayJoinArgs = valueArgsModel([
+    {'name': 'array', 'type': 'array'},
+    {'name': 'separator', 'type': 'string'}
+]);
+
 
 // $function: arrayLastIndexOf
 // $group: Array
@@ -117,41 +136,50 @@ function arrayJoin([array = null, separator = null]) {
 // $arg value: The value to find in the array, or a match function, f(value) -> bool
 // $arg index: Optional (default is the end of the array). The index at which to start the search.
 // $return: The last index of the value in the array; -1 if not found.
-function arrayLastIndexOf([array = null, value = null, indexArg = null], options) {
+function arrayLastIndexOf(args, options) {
+    const [array, value, indexArg] = valueArgsValidate(arrayLastIndexOfArgs, args, -1);
     let index = indexArg;
-    if (valueType(array) === 'array' && index === null) {
+    if (index === null) {
         index = array.length - 1;
     }
-    if (valueType(array) !== 'array' ||
-        valueType(index) !== 'number' || Math.floor(index) !== index || index < 0 || index >= array.length) {
-        return -1;
+    if (index >= array.length) {
+        throw new ValueArgsError('index', index, -1);
     }
 
+    // Value function?
     if (valueType(value) === 'function') {
         for (let ix = index; ix >= 0; ix -= 1) {
             if (valueBoolean(value([array[ix]], options))) {
                 return ix;
             }
         }
+        return -1;
     }
 
     return array.lastIndexOf(value, index);
 }
 
+const arrayLastIndexOfArgs = valueArgsModel([
+    {'name': 'array', 'type': 'array'},
+    {'name': 'value'},
+    {'name': 'index', 'type': 'number', 'nullable': true, 'integer': true, 'gte': 0}
+]);
+
 
 // $function: arrayLength
 // $group: Array
 // $doc: Get the length of an array
 // $arg array: The array
 // $return: The array's length; zero if not an array
-function arrayLength([array = null]) {
-    if (valueType(array) !== 'array') {
-        return 0;
-    }
-
+function arrayLength(args) {
+    const [array] = valueArgsValidate(arrayLengthArgs, args, 0);
     return array.length;
 }
 
+const arrayLengthArgs = valueArgsModel([
+    {'name': 'array', 'type': 'array'}
+]);
+
 
 // $function: arrayNew
 // $group: Array
@@ -169,28 +197,34 @@ function arrayNew(values) {
 // $arg size: Optional (default is 0). The new array's size.
 // $arg value: Optional (default is 0). The value with which to fill the new array.
 // $return: The new array
-function arrayNewSize([size = 0, value = 0]) {
-    if (valueType(size) !== 'number' || Math.floor(size) !== size || size < 0) {
-        return null;
-    }
-
+function arrayNewSize(args) {
+    const [size, value] = valueArgsValidate(arrayNewSizeArgs, args);
     return new Array(size).fill(value);
 }
 
+const arrayNewSizeArgs = valueArgsModel([
+    {'name': 'size', 'type': 'number', 'default': 0, 'integer': true, 'gte': 0},
+    {'name': 'value', 'default': 0}
+]);
+
 
 // $function: arrayPop
 // $group: Array
 // $doc: Remove the last element of the array and return it
 // $arg array: The array
 // $return: The last element of the array; null if the array is empty.
-function arrayPop([array = null]) {
-    if (valueType(array) !== 'array' || array.length === 0) {
-        return null;
+function arrayPop(args) {
+    const [array] = valueArgsValidate(arrayPopArgs, args);
+    if (array.length === 0) {
+        throw new ValueArgsError('array', array);
     }
-
     return array.pop();
 }
 
+const arrayPopArgs = valueArgsModel([
+    {'name': 'array', 'type': 'array'}
+]);
+
 
 // $function: arrayPush
 // $group: Array
@@ -198,15 +232,17 @@ function arrayPop([array = null]) {
 // $arg array: The array
 // $arg values...: The values to add to the end of the array
 // $return: The array
-function arrayPush([array = null, ...values]) {
-    if (valueType(array) !== 'array') {
-        return null;
-    }
-
+function arrayPush(args) {
+    const [array, values] = valueArgsValidate(arrayPushArgs, args);
     array.push(...values);
     return array;
 }
 
+const arrayPushArgs = valueArgsModel([
+    {'name': 'array', 'type': 'array'},
+    {'name': 'values', 'lastArgArray': true}
+]);
+
 
 // $function: arraySet
 // $group: Array
@@ -215,30 +251,40 @@ function arrayPush([array = null, ...values]) {
 // $arg index: The index of the element to set
 // $arg value: The value to set
 // $return: The value
-function arraySet([array = null, index = null, value = null]) {
-    if (valueType(array) !== 'array' ||
-        valueType(index) !== 'number' || Math.floor(index) !== index || index < 0 || index >= array.length) {
-        return null;
+function arraySet(args) {
+    const [array, index, value] = valueArgsValidate(arraySetArgs, args);
+    if (index >= array.length) {
+        throw new ValueArgsError('index', index);
     }
 
     array[index] = value;
     return value;
 }
 
+const arraySetArgs = valueArgsModel([
+    {'name': 'array', 'type': 'array'},
+    {'name': 'index', 'type': 'number', 'integer': true, 'gte': 0},
+    {'name': 'value'}
+]);
+
 
 // $function: arrayShift
 // $group: Array
 // $doc: Remove the first element of the array and return it
 // $arg array: The array
 // $return: The first element of the array; null if the array is empty.
-function arrayShift([array = null]) {
-    if (valueType(array) !== 'array' || array.length === 0) {
-        return null;
+function arrayShift(args) {
+    const [array] = valueArgsValidate(arrayShiftArgs, args);
+    if (array.length === 0) {
+        throw new ValueArgsError('array', array);
     }
-
     return array.shift();
 }
 
+const arrayShiftArgs = valueArgsModel([
+    {'name': 'array', 'type': 'array'}
+]);
+
 
 // $function: arraySlice
 // $group: Array
@@ -247,20 +293,25 @@ function arrayShift([array = null]) {
 // $arg start: Optional (default is 0). The start index of the slice.
 // $arg end: Optional (default is the end of the array). The end index of the slice.
 // $return: The new array slice
-function arraySlice([array = null, start = 0, endArg = null]) {
-    let end = endArg;
-    if (valueType(array) === 'array' && end === null) {
-        end = array.length;
+function arraySlice(args) {
+    const [array, start, endArg] = valueArgsValidate(arraySliceArgs, args);
+    const end = endArg !== null ? endArg : array.length;
+    if (start > array.length) {
+        throw new ValueArgsError('start', start);
     }
-    if (valueType(array) !== 'array' ||
-        valueType(start) !== 'number' || Math.floor(start) !== start || start < 0 || start > array.length ||
-        valueType(end) !== 'number' || Math.floor(end) !== end || end < 0 || end > array.length) {
-        return null;
+    if (end > array.length) {
+        throw new ValueArgsError('end', end);
     }
 
     return array.slice(start, end);
 }
 
+const arraySliceArgs = valueArgsModel([
+    {'name': 'array', 'type': 'array'},
+    {'name': 'start', 'type': 'number', 'default': 0, 'integer': true, 'gte': 0},
+    {'name': 'end', 'type': 'number', 'nullable': true, 'integer': true, 'gte': 0}
+]);
+
 
 // $function: arraySort
 // $group: Array
@@ -268,17 +319,19 @@ function arraySlice([array = null, start = 0, endArg = null]) {
 // $arg array: The array
 // $arg compareFn: Optional (default is null). The comparison function.
 // $return: The sorted array
-function arraySort([array = null, compareFn = null], options) {
-    if (valueType(array) !== 'array' || (compareFn !== null && valueType(compareFn) !== 'function')) {
-        return null;
-    }
-
+function arraySort(args, options) {
+    const [array, compareFn] = valueArgsValidate(arraySortArgs, args);
     if (compareFn === null) {
         return array.sort(valueCompare);
     }
-    return array.sort((...args) => compareFn(args, options));
+    return array.sort((...sortArgs) => compareFn(sortArgs, options));
 }
 
+const arraySortArgs = valueArgsModel([
+    {'name': 'array', 'type': 'array'},
+    {'name': 'compareFn', 'type': 'function', 'nullable': true}
+]);
+
 
 //
 // Data functions
@@ -291,14 +344,16 @@ function arraySort([array = null, compareFn = null], options) {
 // $arg data: The data array
 // $arg aggregation: The [aggregation model](model.html#var.vName='Aggregation')
 // $return: The aggregated data array
-function dataAggregate([data = null, aggregation = null]) {
-    if (valueType(data) !== 'array' || (aggregation !== null && valueType(aggregation) !== 'object')) {
-        return null;
-    }
-
+function dataAggregate(args) {
+    const [data, aggregation] = valueArgsValidate(dataAggregateArgs, args);
     return aggregateData(data, aggregation);
 }
 
+const dataAggregateArgs = valueArgsModel([
+    {'name': 'data', 'type': 'array'},
+    {'name': 'aggregation', 'type': 'object'}
+]);
+
 
 // $function: dataCalculatedField
 // $group: Data
@@ -308,15 +363,19 @@ function dataAggregate([data = null, aggregation = null]) {
 // $arg expr: The calculated field expression
 // $arg variables: Optional (default is null). A variables object the expression evaluation.
 // $return: The updated data array
-function dataCalculatedField([data = null, fieldName = null, expr = null, variables = null], options) {
-    if (valueType(data) !== 'array' || valueType(fieldName) !== 'string' || valueType(expr) !== 'string' ||
-        (variables !== null && valueType(variables) !== 'object')) {
-        return null;
-    }
-
+function dataCalculatedField(args, options) {
+    const [data, fieldName, expr, variables] = valueArgsValidate(dataCalculatedFieldArgs, args);
     return addCalculatedField(data, fieldName, expr, variables, options);
 }
 
+const dataCalculatedFieldArgs = valueArgsModel([
+    {'name': 'data', 'type': 'array'},
+    {'name': 'fieldName', 'type': 'string'},
+    {'name': 'expr', 'type': 'string'},
+    {'name': 'variables', 'type': 'object', 'nullable': true}
+]);
+
+
 // $function: dataFilter
 // $group: Data
 // $doc: Filter a data array
@@ -324,14 +383,17 @@ function dataCalculatedField([data = null, fieldName = null, expr = null, variab
 // $arg expr: The filter expression
 // $arg variables: Optional (default is null). A variables object the expression evaluation.
 // $return: The filtered data array
-function dataFilter([data = null, expr = null, variables = null], options) {
-    if (valueType(data) !== 'array' || valueType(expr) !== 'string' || (variables !== null && valueType(variables) !== 'object')) {
-        return null;
-    }
-
+function dataFilter(args, options) {
+    const [data, expr, variables] = valueArgsValidate(dataFilterArgs, args);
     return filterData(data, expr, variables, options);
 }
 
+const dataFilterArgs = valueArgsModel([
+    {'name': 'data', 'type': 'array'},
+    {'name': 'expr', 'type': 'string'},
+    {'name': 'variables', 'type': 'object', 'nullable': true}
+]);
+
 
 // $function: dataJoin
 // $group: Data
@@ -344,15 +406,20 @@ function dataFilter([data = null, expr = null, variables = null], options) {
 // $arg isLeftJoin: Optional (default is false). If true, perform a left join (always include left row).
 // $arg variables: Optional (default is null). A variables object for join expression evaluation.
 // $return: The joined data array
-function dataJoin([leftData = null, rightData = null, joinExpr = null, rightExpr = null, isLeftJoin = false, variables = null], options) {
-    if (valueType(leftData) !== 'array' || valueType(rightData) !== 'array' || valueType(joinExpr) !== 'string' ||
-        (rightExpr !== null && valueType(rightExpr) !== 'string') || (variables !== null && valueType(variables) !== 'object')) {
-        return null;
-    }
-
+function dataJoin(args, options) {
+    const [leftData, rightData, joinExpr, rightExpr, isLeftJoin, variables] = valueArgsValidate(dataJoinArgs, args);
     return joinData(leftData, rightData, joinExpr, rightExpr, isLeftJoin, variables, options);
 }
 
+const dataJoinArgs = valueArgsModel([
+    {'name': 'leftData', 'type': 'array'},
+    {'name': 'rightData', 'type': 'array'},
+    {'name': 'joinExpr', 'type': 'string'},
+    {'name': 'rightExpr', 'type': 'string', 'nullable': true},
+    {'name': 'isLeftJoin', 'type': 'boolean', 'default': false},
+    {'name': 'variables', 'type': 'object', 'nullable': true}
+]);
+
 
 // $function: dataParseCSV
 // $group: Data
@@ -367,7 +434,7 @@ function dataParseCSV(args) {
             continue;
         }
         if (valueType(arg) !== 'string') {
-            return null;
+            throw new ValueArgsError('text', arg);
         }
         lines.push(arg);
     }
@@ -384,14 +451,16 @@ function dataParseCSV(args) {
 // $arg data: The data array
 // $arg sorts: The sort field-name/descending-sort tuples
 // $return: The sorted data array
-function dataSort([data = null, sorts = null]) {
-    if (valueType(data) !== 'array' || valueType(sorts) !== 'array') {
-        return null;
-    }
-
+function dataSort(args) {
+    const [data, sorts] = valueArgsValidate(dataSortArgs, args);
     return sortData(data, sorts);
 }
 
+const dataSortArgs = valueArgsModel([
+    {'name': 'data', 'type': 'array'},
+    {'name': 'sorts', 'type': 'array'}
+]);
+
 
 // $function: dataTop
 // $group: Data
@@ -400,16 +469,17 @@ function dataSort([data = null, sorts = null]) {
 // $arg count: The number of rows to keep (default is 1)
 // $arg categoryFields: Optional (default is null). The category fields.
 // $return: The top data array
-function dataTop([data = null, count = null, categoryFields = null]) {
-    if (valueType(data) !== 'array' ||
-        valueType(count) !== 'number' || Math.floor(count) !== count || count < 1 ||
-        (categoryFields !== null && valueType(categoryFields) !== 'array')) {
-        return null;
-    }
-
+function dataTop(args) {
+    const [data, count, categoryFields] = valueArgsValidate(dataTopArgs, args);
     return topData(data, count, categoryFields);
 }
 
+const dataTopArgs = valueArgsModel([
+    {'name': 'data', 'type': 'array'},
+    {'name': 'count', 'type': 'number', 'integer': true, 'gte': 1},
+    {'name': 'categoryFields', 'type': 'array', 'nullable': true}
+]);
+
 
 // $function: dataValidate
 // $group: Data
@@ -417,15 +487,17 @@ function dataTop([data = null, count = null, categoryFields = null]) {
 // $arg data: The data array
 // $arg csv: Optional (default is false). If true, parse value strings.
 // $return: The validated data array
-function dataValidate([data = null, csv = false]) {
-    if (valueType(data) !== 'array') {
-        return null;
-    }
-
-    validateData(data, valueBoolean(csv));
+function dataValidate(args) {
+    const [data, csv] = valueArgsValidate(dataValidateArgs, args);
+    validateData(data, csv);
     return data;
 }
 
+const dataValidateArgs = valueArgsModel([
+    {'name': 'data', 'type': 'array'},
+    {'name': 'csv', 'type': 'boolean', 'default': false}
+]);
+
 
 //
 // Datetime functions
@@ -437,28 +509,30 @@ function dataValidate([data = null, csv = false]) {
 // $doc: Get the day of the month of a datetime
 // $arg datetime: The datetime
 // $return: The day of the month
-function datetimeDay([datetime = null]) {
-    if (valueType(datetime) !== 'datetime') {
-        return null;
-    }
-
+function datetimeDay(args) {
+    const [datetime] = valueArgsValidate(datetimeDayArgs, args);
     return datetime.getDate();
 }
 
+const datetimeDayArgs = valueArgsModel([
+    {'name': 'datetime', 'type': 'datetime'}
+]);
+
 
 // $function: datetimeHour
 // $group: Datetime
 // $doc: Get the hour of a datetime
 // $arg datetime: The datetime
 // $return: The hour
-function datetimeHour([datetime = null]) {
-    if (valueType(datetime) !== 'datetime') {
-        return null;
-    }
-
+function datetimeHour(args) {
+    const [datetime] = valueArgsValidate(datetimeHourArgs, args);
     return datetime.getHours();
 }
 
+const datetimeHourArgs = valueArgsModel([
+    {'name': 'datetime', 'type': 'datetime'}
+]);
+
 
 // $function: datetimeISOFormat
 // $group: Datetime
@@ -466,12 +540,10 @@ function datetimeHour([datetime = null]) {
 // $arg datetime: The datetime
 // $arg isDate: If true, format the datetime as an ISO date
 // $return: The formatted datetime string
-function datetimeISOFormat([datetime = null, isDate = false]) {
-    if (valueType(datetime) !== 'datetime') {
-        return null;
-    }
+function datetimeISOFormat(args) {
+    const [datetime, isDate] = valueArgsValidate(datetimeISOFormatArgs, args);
 
-    if (valueBoolean(isDate)) {
+    if (isDate) {
         const year = String(datetime.getFullYear()).padStart(4, '0');
         const month = String(datetime.getMonth() + 1).padStart(2, '0');
         const day = String(datetime.getDate()).padStart(2, '0');
@@ -481,62 +553,71 @@ function datetimeISOFormat([datetime = null, isDate = false]) {
     return valueString(datetime);
 }
 
+const datetimeISOFormatArgs = valueArgsModel([
+    {'name': 'datetime', 'type': 'datetime'},
+    {'name': 'isDate', 'type': 'boolean', 'default': false}
+]);
+
 
 // $function: datetimeISOParse
 // $group: Datetime
 // $doc: Parse an ISO date/time string
 // $arg string: The ISO date/time string
 // $return: The datetime, or null if parsing fails
-function datetimeISOParse([string]) {
-    if (valueType(string) !== 'string') {
-        return null;
-    }
-
+function datetimeISOParse(args) {
+    const [string] = valueArgsValidate(datetimeISOParseArgs, args);
     return valueParseDatetime(string);
 }
 
+const datetimeISOParseArgs = valueArgsModel([
+    {'name': 'string', 'type': 'string'}
+]);
+
 
 // $function: datetimeMillisecond
 // $group: Datetime
 // $doc: Get the millisecond of a datetime
 // $arg datetime: The datetime
 // $return: The millisecond
-function datetimeMillisecond([datetime = null]) {
-    if (valueType(datetime) !== 'datetime') {
-        return null;
-    }
-
+function datetimeMillisecond(args) {
+    const [datetime] = valueArgsValidate(datetimeMillisecondArgs, args);
     return datetime.getMilliseconds();
 }
 
+const datetimeMillisecondArgs = valueArgsModel([
+    {'name': 'datetime', 'type': 'datetime'}
+]);
+
 
 // $function: datetimeMinute
 // $group: Datetime
 // $doc: Get the minute of a datetime
 // $arg datetime: The datetime
 // $return: The minute
-function datetimeMinute([datetime = null]) {
-    if (valueType(datetime) !== 'datetime') {
-        return null;
-    }
-
+function datetimeMinute(args) {
+    const [datetime] = valueArgsValidate(datetimeMinuteArgs, args);
     return datetime.getMinutes();
 }
 
+const datetimeMinuteArgs = valueArgsModel([
+    {'name': 'datetime', 'type': 'datetime'}
+]);
+
 
 // $function: datetimeMonth
 // $group: Datetime
 // $doc: Get the month (1-12) of a datetime
 // $arg datetime: The datetime
 // $return: The month
-function datetimeMonth([datetime = null]) {
-    if (valueType(datetime) !== 'datetime') {
-        return null;
-    }
-
+function datetimeMonth(args) {
+    const [datetime] = valueArgsValidate(datetimeMonthArgs, args);
     return datetime.getMonth() + 1;
 }
 
+const datetimeMonthArgs = valueArgsModel([
+    {'name': 'datetime', 'type': 'datetime'}
+]);
+
 
 // $function: datetimeNew
 // $group: Datetime
@@ -549,20 +630,21 @@ function datetimeMonth([datetime = null]) {
 // $arg second: Optional (default is 0). The second.
 // $arg millisecond: Optional (default is 0). The millisecond.
 // $return: The new datetime
-function datetimeNew([year, month, day, hour = 0, minute = 0, second = 0, millisecond = 0]) {
-    if (valueType(year) !== 'number' || Math.floor(year) !== year || year < 100 ||
-        valueType(month) !== 'number' || Math.floor(month) !== month ||
-        valueType(day) !== 'number' || Math.floor(day) !== day || day < -10000 || day > 10000 ||
-        valueType(hour) !== 'number' || Math.floor(hour) !== hour ||
-        valueType(minute) !== 'number' || Math.floor(minute) !== minute ||
-        valueType(second) !== 'number' || Math.floor(second) !== second ||
-        valueType(millisecond) !== 'number' || Math.floor(millisecond) !== millisecond) {
-        return null;
-    }
-
+function datetimeNew(args) {
+    const [year, month, day, hour, minute, second, millisecond] = valueArgsValidate(datetimeNewArgs, args);
     return new Date(year, month - 1, day, hour, minute, second, millisecond);
 }
 
+const datetimeNewArgs = valueArgsModel([
+    {'name': 'year', 'type': 'number', 'integer': true, 'gte': 100},
+    {'name': 'month', 'type': 'number', 'integer': true},
+    {'name': 'day', 'type': 'number', 'integer': true, 'gte': -10000, 'lte': 10000},
+    {'name': 'hour', 'type': 'number', 'default': 0, 'integer': true},
+    {'name': 'minute', 'type': 'number', 'default': 0, 'integer': true},
+    {'name': 'second', 'type': 'number', 'default': 0, 'integer': true},
+    {'name': 'millisecond', 'type': 'number', 'default': 0, 'integer': true}
+]);
+
 
 // $function: datetimeNow
 // $group: Datetime
@@ -578,14 +660,15 @@ function datetimeNow() {
 // $doc: Get the second of a datetime
 // $arg datetime: The datetime
 // $return: The second
-function datetimeSecond([datetime = null]) {
-    if (valueType(datetime) !== 'datetime') {
-        return null;
-    }
-
+function datetimeSecond(args) {
+    const [datetime] = valueArgsValidate(datetimeSecondArgs, args);
     return datetime.getSeconds();
 }
 
+const datetimeSecondArgs = valueArgsModel([
+    {'name': 'datetime', 'type': 'datetime'}
+]);
+
 
 // $function: datetimeToday
 // $group: Datetime
@@ -602,14 +685,15 @@ function datetimeToday() {
 // $doc: Get the full year of a datetime
 // $arg datetime: The datetime
 // $return: The full year
-function datetimeYear([datetime = null]) {
-    if (valueType(datetime) !== 'datetime') {
-        return null;
-    }
-
+function datetimeYear(args) {
+    const [datetime] = valueArgsValidate(datetimeYearArgs, args);
     return datetime.getFullYear();
 }
 
+const datetimeYearArgs = valueArgsModel([
+    {'name': 'datetime', 'type': 'datetime'}
+]);
+
 
 //
 // JSON functions
@@ -621,14 +705,15 @@ function datetimeYear([datetime = null]) {
 // $doc: Convert a JSON string to an object
 // $arg string: The JSON string
 // $return: The object
-function jsonParse([string = null]) {
-    if (valueType(string) !== 'string') {
-        return null;
-    }
-
+function jsonParse(args) {
+    const [string] = valueArgsValidate(jsonParseArgs, args);
     return JSON.parse(string);
 }
 
+const jsonParseArgs = valueArgsModel([
+    {'name': 'string', 'type': 'string'}
+]);
+
 
 // $function: jsonStringify
 // $group: JSON
@@ -636,74 +721,81 @@ function jsonParse([string = null]) {
 // $arg value: The object
 // $arg indent: Optional (default is null). The indentation number.
 // $return: The JSON string
-function jsonStringify([value = null, indent = null]) {
-    if (indent !== null && (valueType(indent) !== 'number' || Math.floor(indent) !== indent || indent < 1)) {
-        return null;
-    }
-
+function jsonStringify(args) {
+    const [value, indent] = valueArgsValidate(jsonStringifyArgs, args);
     return valueJSON(value, indent);
 }
 
+const jsonStringifyArgs = valueArgsModel([
+    {'name': 'value'},
+    {'name': 'indent', 'type': 'number', 'nullable': true, 'integer': true, 'gte': 1}
+]);
+
 
 //
 // Math functions
 //
 
+
 // $function: mathAbs
 // $group: Math
 // $doc: Compute the absolute value of a number
 // $arg x: The number
 // $return: The absolute value of the number
-function mathAbs([x = null]) {
-    if (valueType(x) !== 'number') {
-        return null;
-    }
-
+function mathAbs(args) {
+    const [x] = valueArgsValidate(mathAbsArgs, args);
     return Math.abs(x);
 }
 
+const mathAbsArgs = valueArgsModel([
+    {'name': 'x', 'type': 'number'}
+]);
+
 
 // $function: mathAcos
 // $group: Math
 // $doc: Compute the arccosine, in radians, of a number
 // $arg x: The number
 // $return: The arccosine, in radians, of the number
-function mathAcos([x = null]) {
-    if (valueType(x) !== 'number') {
-        return null;
-    }
-
+function mathAcos(args) {
+    const [x] = valueArgsValidate(mathAcosArgs, args);
     return Math.acos(x);
 }
 
+const mathAcosArgs = valueArgsModel([
+    {'name': 'x', 'type': 'number'}
+]);
+
 
 // $function: mathAsin
 // $group: Math
 // $doc: Compute the arcsine, in radians, of a number
 // $arg x: The number
 // $return: The arcsine, in radians, of the number
-function mathAsin([x = null]) {
-    if (valueType(x) !== 'number') {
-        return null;
-    }
-
+function mathAsin(args) {
+    const [x] = valueArgsValidate(mathAsinArgs, args);
     return Math.asin(x);
 }
 
+const mathAsinArgs = valueArgsModel([
+    {'name': 'x', 'type': 'number'}
+]);
+
 
 // $function: mathAtan
 // $group: Math
 // $doc: Compute the arctangent, in radians, of a number
 // $arg x: The number
 // $return: The arctangent, in radians, of the number
-function mathAtan([x = null]) {
-    if (valueType(x) !== 'number') {
-        return null;
-    }
-
+function mathAtan(args) {
+    const [x] = valueArgsValidate(mathAtanArgs, args);
     return Math.atan(x);
 }
 
+const mathAtanArgs = valueArgsModel([
+    {'name': 'x', 'type': 'number'}
+]);
+
 
 // $function: mathAtan2
 // $group: Math
@@ -711,70 +803,76 @@ function mathAtan([x = null]) {
 // $arg y: The Y-coordinate of the point
 // $arg x: The X-coordinate of the point
 // $return: The angle, in radians
-function mathAtan2([y = null, x = null]) {
-    if (valueType(y) !== 'number' || valueType(x) !== 'number') {
-        return null;
-    }
-
+function mathAtan2(args) {
+    const [y, x] = valueArgsValidate(mathAtan2Args, args);
     return Math.atan2(y, x);
 }
 
+const mathAtan2Args = valueArgsModel([
+    {'name': 'y', 'type': 'number'},
+    {'name': 'x', 'type': 'number'}
+]);
+
 
 // $function: mathCeil
 // $group: Math
 // $doc: Compute the ceiling of a number (round up to the next highest integer)
 // $arg x: The number
 // $return: The ceiling of the number
-function mathCeil([x = null]) {
-    if (valueType(x) !== 'number') {
-        return null;
-    }
-
+function mathCeil(args) {
+    const [x] = valueArgsValidate(mathCeilArgs, args);
     return Math.ceil(x);
 }
 
+const mathCeilArgs = valueArgsModel([
+    {'name': 'x', 'type': 'number'}
+]);
+
 
 // $function: mathCos
 // $group: Math
 // $doc: Compute the cosine of an angle, in radians
 // $arg x: The angle, in radians
 // $return: The cosine of the angle
-function mathCos([x = null]) {
-    if (valueType(x) !== 'number') {
-        return null;
-    }
-
+function mathCos(args) {
+    const [x] = valueArgsValidate(mathCosArgs, args);
     return Math.cos(x);
 }
 
+const mathCosArgs = valueArgsModel([
+    {'name': 'x', 'type': 'number'}
+]);
+
 
 // $function: mathFloor
 // $group: Math
 // $doc: Compute the floor of a number (round down to the next lowest integer)
 // $arg x: The number
 // $return: The floor of the number
-function mathFloor([x = null]) {
-    if (valueType(x) !== 'number') {
-        return null;
-    }
-
+function mathFloor(args) {
+    const [x] = valueArgsValidate(mathFloorArgs, args);
     return Math.floor(x);
 }
 
+const mathFloorArgs = valueArgsModel([
+    {'name': 'x', 'type': 'number'}
+]);
+
 
 // $function: mathLn
 // $group: Math
 // $doc: Compute the natural logarithm (base e) of a number
 // $arg x: The number
 // $return: The natural logarithm of the number
-function mathLn([x = null]) {
-    if (valueType(x) !== 'number' || x <= 0) {
-        return null;
-    }
-
+function mathLn(args) {
+    const [x] = valueArgsValidate(mathLnArgs, args);
     return Math.log(x);
 }
 
+const mathLnArgs = valueArgsModel([
+    {'name': 'x', 'type': 'number', 'gt': 0}
+]);
+
 
 // $function: mathLog
 // $group: Math
@@ -782,14 +880,20 @@ function mathLn([x = null]) {
 // $arg x: The number
 // $arg base: Optional (default is 10). The logarithm base.
 // $return: The logarithm of the number
-function mathLog([x = null, base = 10]) {
-    if (valueType(x) !== 'number' || x <= 0 || valueType(base) !== 'number' || base <= 0 || base === 1) {
-        return null;
+function mathLog(args) {
+    const [x, base] = valueArgsValidate(mathLogArgs, args);
+    if (base === 1) {
+        throw new ValueArgsError('base', base);
     }
 
     return Math.log(x) / Math.log(base);
 }
 
+const mathLogArgs = valueArgsModel([
+    {'name': 'x', 'type': 'number', 'gt': 0},
+    {'name': 'base', 'type': 'number', 'default': 10, 'gt': 0}
+]);
+
 
 // $function: mathMax
 // $group: Math
@@ -797,11 +901,13 @@ function mathLog([x = null, base = 10]) {
 // $arg values...: The values
 // $return: The maximum value
 function mathMax(values) {
-    if (values.some((value) => valueType(value) !== 'number')) {
-        return null;
+    let result;
+    for (const value of values) {
+        if (typeof result === 'undefined' || valueCompare(value, result) > 0) {
+            result = value;
+        }
     }
-
-    return Math.max(...values);
+    return result ?? null;
 }
 
 
@@ -811,11 +917,13 @@ function mathMax(values) {
 // $arg values...: The values
 // $return: The minimum value
 function mathMin(values) {
-    if (values.some((value) => valueType(value) !== 'number')) {
-        return null;
+    let result;
+    for (const value of values) {
+        if (typeof result === 'undefined' || valueCompare(value, result) < 0) {
+            result = value;
+        }
     }
-
-    return Math.min(...values);
+    return result ?? null;
 }
 
 
@@ -843,71 +951,76 @@ function mathRandom() {
 // $arg x: The number
 // $arg digits: Optional (default is 0). The number of decimal digits to round to.
 // $return: The rounded number
-function mathRound([x = null, digits = 0]) {
-    if (valueType(x) !== 'number' || valueType(digits) !== 'number' || Math.floor(digits) !== digits || digits < 0) {
-        return null;
-    }
-
-    const multiplier = 10 ** digits;
-    return Math.round(x * multiplier) / multiplier;
+function mathRound(args) {
+    const [x, digits] = valueArgsValidate(mathRoundArgs, args);
+    return valueRoundNumber(x, digits);
 }
 
+const mathRoundArgs = valueArgsModel([
+    {'name': 'x', 'type': 'number'},
+    {'name': 'digits', 'type': 'number', 'default': 0, 'integer': true, 'gte': 0}
+]);
+
 
 // $function: mathSign
 // $group: Math
 // $doc: Compute the sign of a number
 // $arg x: The number
 // $return: -1 for a negative number, 1 for a positive number, and 0 for zero
-function mathSign([x = null]) {
-    if (valueType(x) !== 'number') {
-        return null;
-    }
-
+function mathSign(args) {
+    const [x] = valueArgsValidate(mathSignArgs, args);
     return Math.sign(x);
 }
 
+const mathSignArgs = valueArgsModel([
+    {'name': 'x', 'type': 'number'}
+]);
+
 
 // $function: mathSin
 // $group: Math
 // $doc: Compute the sine of an angle, in radians
 // $arg x: The angle, in radians
 // $return: The sine of the angle
-function mathSin([x = null]) {
-    if (valueType(x) !== 'number') {
-        return null;
-    }
-
+function mathSin(args) {
+    const [x] = valueArgsValidate(mathSinArgs, args);
     return Math.sin(x);
 }
 
+const mathSinArgs = valueArgsModel([
+    {'name': 'x', 'type': 'number'}
+]);
+
 
 // $function: mathSqrt
 // $group: Math
 // $doc: Compute the square root of a number
 // $arg x: The number
 // $return: The square root of the number
-function mathSqrt([x = null]) {
-    if (valueType(x) !== 'number' || x < 0) {
-        return null;
-    }
-
+function mathSqrt(args) {
+    const [x] = valueArgsValidate(mathSqrtArgs, args);
     return Math.sqrt(x);
 }
 
+const mathSqrtArgs = valueArgsModel([
+    {'name': 'x', 'type': 'number', 'gte': 0}
+]);
+
 
 // $function: mathTan
 // $group: Math
 // $doc: Compute the tangent of an angle, in radians
 // $arg x: The angle, in radians
 // $return: The tangent of the angle
-function mathTan([x = null]) {
-    if (valueType(x) !== 'number') {
-        return null;
-    }
-
+function mathTan(args) {
+    const [x] = valueArgsValidate(mathTanArgs, args);
     return Math.tan(x);
 }
 
+const mathTanArgs = valueArgsModel([
+    {'name': 'x', 'type': 'number'}
+]);
+
 
 //
 // Number functions
@@ -919,14 +1032,15 @@ function mathTan([x = null]) {
 // $doc: Parse a string as a floating point number
 // $arg string: The string
 // $return: The number
-function numberParseFloat([string = null]) {
-    if (valueType(string) !== 'string') {
-        return null;
-    }
-
+function numberParseFloat(args) {
+    const [string] = valueArgsValidate(numberParseFloatArgs, args);
     return valueParseNumber(string);
 }
 
+const numberParseFloatArgs = valueArgsModel([
+    {'name': 'string', 'type': 'string'}
+]);
+
 
 // $function: numberParseInt
 // $group: Number
@@ -934,14 +1048,16 @@ function numberParseFloat([string = null]) {
 // $arg string: The string
 // $arg radix: Optional (default is 10). The number base.
 // $return: The integer
-function numberParseInt([string = null, radix = 10]) {
-    if (valueType(string) !== 'string' || valueType(radix) !== 'number' || Math.floor(radix) !== radix || radix < 2 || radix > 36) {
-        return null;
-    }
-
+function numberParseInt(args) {
+    const [string, radix] = valueArgsValidate(numberParseIntArgs, args);
     return valueParseInteger(string, radix);
 }
 
+const numberParseIntArgs = valueArgsModel([
+    {'name': 'string', 'type': 'string'},
+    {'name': 'radix', 'type': 'number', 'default': 10, 'integer': true, 'gte': 2, 'lte': 36}
+]);
+
 
 // $function: numberToFixed
 // $group: Number
@@ -950,18 +1066,21 @@ function numberParseInt([string = null, radix = 10]) {
 // $arg digits: Optional (default is 2). The number of digits to appear after the decimal point.
 // $arg trim: Optional (default is false). If true, trim trailing zeroes and decimal point.
 // $return: The fixed-point notation string
-function numberToFixed([x = null, digits = 2, trim = false]) {
-    if (valueType(x) !== 'number' || valueType(digits) !== 'number' || Math.floor(digits) !== digits || digits < 0) {
-        return null;
-    }
-
+function numberToFixed(args) {
+    const [x, digits, trim] = valueArgsValidate(numberToFixedArgs, args);
     let result = x.toFixed(digits);
-    if (valueBoolean(trim)) {
+    if (trim) {
         result = result.replace(rNumberCleanup, '');
     }
     return result;
 }
 
+const numberToFixedArgs = valueArgsModel([
+    {'name': 'x', 'type': 'number'},
+    {'name': 'digits', 'type': 'number', 'default': 2, 'integer': true, 'gte': 0},
+    {'name': 'trim', 'type': 'boolean', 'default': false}
+]);
+
 const rNumberCleanup = /\.0*$/;
 
 
@@ -976,44 +1095,48 @@ const rNumberCleanup = /\.0*$/;
 // $arg object: The object to assign to
 // $arg object2: The object to assign
 // $return: The updated object
-function objectAssign([object = null, object2 = null]) {
-    if (valueType(object) !== 'object' || valueType(object2) !== 'object') {
-        return null;
-    }
-
+function objectAssign(args) {
+    const [object, object2] = valueArgsValidate(objectAssignArgs, args);
     Object.assign(object, object2);
     return object;
 }
 
+const objectAssignArgs = valueArgsModel([
+    {'name': 'object', 'type': 'object'},
+    {'name': 'object2', 'type': 'object'}
+]);
+
 
 // $function: objectCopy
 // $group: Object
 // $doc: Create a copy of an object
 // $arg object: The object to copy
 // $return: The object copy
-function objectCopy([object = null]) {
-    if (valueType(object) !== 'object') {
-        return null;
-    }
-
+function objectCopy(args) {
+    const [object] = valueArgsValidate(objectCopyArgs, args);
     return {...object};
 }
 
+const objectCopyArgs = valueArgsModel([
+    {'name': 'object', 'type': 'object'}
+]);
+
 
 // $function: objectDelete
 // $group: Object
 // $doc: Delete an object key
 // $arg object: The object
 // $arg key: The key to delete
-function objectDelete([object = null, key = null]) {
-    if (valueType(object) !== 'object' || valueType(key) !== 'string') {
-        return null;
-    }
-
+function objectDelete(args) {
+    const [object, key] = valueArgsValidate(objectDeleteArgs, args);
     delete object[key];
-    return null;
 }
 
+const objectDeleteArgs = valueArgsModel([
+    {'name': 'object', 'type': 'object'},
+    {'name': 'key', 'type': 'string'}
+]);
+
 
 // $function: objectGet
 // $group: Object
@@ -1022,14 +1145,18 @@ function objectDelete([object = null, key = null]) {
 // $arg key: The key
 // $arg defaultValue: The default value (optional)
 // $return: The value or null if the key does not exist
-function objectGet([object = null, key = null, defaultValue = null]) {
-    if (valueType(object) !== 'object' || valueType(key) !== 'string') {
-        return defaultValue;
-    }
-
+function objectGet(args) {
+    const [,,defaultValueArg = null] = args;
+    const [object, key, defaultValue] = valueArgsValidate(objectGetArgs, args, defaultValueArg);
     return object[key] ?? defaultValue;
 }
 
+const objectGetArgs = valueArgsModel([
+    {'name': 'object', 'type': 'object'},
+    {'name': 'key', 'type': 'string'},
+    {'name': 'defaultValue'}
+]);
+
 
 // $function: objectHas
 // $group: Object
@@ -1037,41 +1164,44 @@ function objectGet([object = null, key = null, defaultValue = null]) {
 // $arg object: The object
 // $arg key: The key
 // $return: true if the object contains the key, false otherwise
-function objectHas([object = null, key = null]) {
-    if (valueType(object) !== 'object' || valueType(key) !== 'string') {
-        return false;
-    }
-
+function objectHas(args) {
+    const [object, key] = valueArgsValidate(objectHasArgs, args, false);
     return key in object;
 }
 
+const objectHasArgs = valueArgsModel([
+    {'name': 'object', 'type': 'object'},
+    {'name': 'key', 'type': 'string'}
+]);
+
 
 // $function: objectKeys
 // $group: Object
 // $doc: Get an object's keys
 // $arg object: The object
 // $return: The array of keys
-function objectKeys([object = null]) {
-    if (valueType(object) !== 'object') {
-        return null;
-    }
-
+function objectKeys(args) {
+    const [object] = valueArgsValidate(objectKeysArgs, args);
     return Object.keys(object);
 }
 
+const objectKeysArgs = valueArgsModel([
+    {'name': 'object', 'type': 'object'}
+]);
+
 
 // $function: objectNew
 // $group: Object
 // $doc: Create a new object
 // $arg keyValues...: The object's initial key and value pairs
 // $return: The new object
-function objectNew(keyValues = null) {
+function objectNew(keyValues) {
     const object = {};
     for (let ix = 0; ix < keyValues.length; ix += 2) {
         const key = keyValues[ix];
         const value = ix + 1 < keyValues.length ? keyValues[ix + 1] : null;
         if (valueType(key) !== 'string') {
-            return null;
+            throw new ValueArgsError('keyValues', key);
         }
         object[key] = value;
     }
@@ -1086,15 +1216,18 @@ function objectNew(keyValues = null) {
 // $arg key: The key
 // $arg value: The value to set
 // $return: The value to set
-function objectSet([object = null, key = null, value = null]) {
-    if (valueType(object) !== 'object' || valueType(key) !== 'string') {
-        return null;
-    }
-
+function objectSet(args) {
+    const [object, key, value] = valueArgsValidate(objectSetArgs, args);
     object[key] = value;
     return value;
 }
 
+const objectSetArgs = valueArgsModel([
+    {'name': 'object', 'type': 'object'},
+    {'name': 'key', 'type': 'string'},
+    {'name': 'value'}
+]);
+
 
 //
 // Regex functions
@@ -1106,14 +1239,15 @@ function objectSet([object = null, key = null, value = null]) {
 // $doc: Escape a string for use in a regular expression
 // $arg string: The string to escape
 // $return: The escaped string
-function regexEscape([string = null]) {
-    if (valueType(string) !== 'string') {
-        return null;
-    }
-
+function regexEscape(args) {
+    const [string] = valueArgsValidate(regexEscapeArgs, args);
     return string.replace(rRegexEscape, '\\$&');
 }
 
+const regexEscapeArgs = valueArgsModel([
+    {'name': 'string', 'type': 'string'}
+]);
+
 const rRegexEscape = /[.*+?^${}()|[\]\\]/g;
 
 
@@ -1123,20 +1257,17 @@ const rRegexEscape = /[.*+?^${}()|[\]\\]/g;
 // $arg regex: The regular expression
 // $arg string: The string
 // $return: The [match object](model.html#var.vName='RegexMatch'), or null if no matches are found
-function regexMatch([regex = null, string = null]) {
-    if (valueType(regex) !== 'regex' || valueType(string) !== 'string') {
-        return null;
-    }
-
-    // Match?
+function regexMatch(args) {
+    const [regex, string] = valueArgsValidate(regexMatchArgs, args);
     const match = string.match(regex);
-    if (match === null) {
-        return null;
-    }
-
-    return regexMatchGroups(match);
+    return match !== null ? regexMatchGroups(match) : null;
 }
 
+const regexMatchArgs = valueArgsModel([
+    {'name': 'regex', 'type': 'regex'},
+    {'name': 'string', 'type': 'string'}
+]);
+
 
 // $function: regexMatchAll
 // $group: Regex
@@ -1144,10 +1275,8 @@ function regexMatch([regex = null, string = null]) {
 // $arg regex: The regular expression
 // $arg string: The string
 // $return: The array of [match objects](model.html#var.vName='RegexMatch')
-function regexMatchAll([regex = null, string = null]) {
-    if (valueType(regex) !== 'regex' || valueType(string) !== 'string') {
-        return null;
-    }
+function regexMatchAll(args) {
+    const [regex, string] = valueArgsValidate(regexMatchAllArgs, args);
 
     // Re-compile the regex with the "g" flag, if necessary
     const regexGlobal = (regex.flags.indexOf('g') !== -1 ? regex : new RegExp(regex.source, `${regex.flags}g`));
@@ -1155,6 +1284,11 @@ function regexMatchAll([regex = null, string = null]) {
     return Array.from(string.matchAll(regexGlobal)).map((match) => regexMatchGroups(match));
 }
 
+const regexMatchAllArgs = valueArgsModel([
+    {'name': 'regex', 'type': 'regex'},
+    {'name': 'string', 'type': 'string'}
+]);
+
 
 // Helper function to create a match model from a metch object
 function regexMatchGroups(match) {
@@ -1204,10 +1338,8 @@ struct RegexMatch
 // $arg flags: - **m** - multi-line search - "^" and "$" matches next to newline characters
 // $arg flags: - **s** - "." matches newline characters
 // $return: The regular expression or null if the pattern is invalid
-function regexNew([pattern = null, flags = null]) {
-    if (valueType(pattern) !== 'string' || (flags !== null && valueType(flags) !== 'string')) {
-        return null;
-    }
+function regexNew(args) {
+    const [pattern, flags] = valueArgsValidate(regexNewArgs, args);
 
     // Valid flags mask?
     if (flags !== null) {
@@ -1221,6 +1353,11 @@ function regexNew([pattern = null, flags = null]) {
     return flags !== null ? new RegExp(pattern, flags) : new RegExp(pattern);
 }
 
+const regexNewArgs = valueArgsModel([
+    {'name': 'pattern', 'type': 'string'},
+    {'name': 'flags', 'type': 'string', 'nullable': true}
+]);
+
 
 // $function: regexReplace
 // $group: Regex
@@ -1229,10 +1366,8 @@ function regexNew([pattern = null, flags = null]) {
 // $arg string: The string
 // $arg substr: The replacement string
 // $return: The updated string
-function regexReplace([regex = null, string = null, substr = null]) {
-    if (valueType(regex) !== 'regex' || valueType(string) !== 'string' || valueType(substr) !== 'string') {
-        return null;
-    }
+function regexReplace(args) {
+    const [regex, string, substr] = valueArgsValidate(regexReplaceArgs, args);
 
     // Re-compile the regex with the "g" flag, if necessary
     const regexGlobal = (regex.flags.indexOf('g') !== -1 ? regex : new RegExp(regex.source, `${regex.flags}g`));
@@ -1240,6 +1375,12 @@ function regexReplace([regex = null, string = null, substr = null]) {
     return string.replaceAll(regexGlobal, substr);
 }
 
+const regexReplaceArgs = valueArgsModel([
+    {'name': 'regex', 'type': 'regex'},
+    {'name': 'string', 'type': 'string'},
+    {'name': 'substr', 'type': 'string'}
+]);
+
 
 // $function: regexSplit
 // $group: Regex
@@ -1247,14 +1388,16 @@ function regexReplace([regex = null, string = null, substr = null]) {
 // $arg regex: The regular expression
 // $arg string: The string
 // $return: The array of split parts
-function regexSplit([regex = null, string = null]) {
-    if (valueType(regex) !== 'regex' || valueType(string) !== 'string') {
-        return null;
-    }
-
+function regexSplit(args) {
+    const [regex, string] = valueArgsValidate(regexSplitArgs, args);
     return string.split(regex);
 }
 
+const regexSplitArgs = valueArgsModel([
+    {'name': 'regex', 'type': 'regex'},
+    {'name': 'string', 'type': 'string'}
+]);
+
 
 //
 // Schema functions
@@ -1280,15 +1423,23 @@ function schemaParse(lines) {
 // $arg types: Optional. The [type model](https://craigahobbs.github.io/schema-markdown-doc/doc/#var.vName='Types').
 // $arg filename: Optional (default is ""). The file name.
 // $return: The schema's [type model](https://craigahobbs.github.io/schema-markdown-doc/doc/#var.vName='Types')
-function schemaParseEx([lines = null, types = {}, filename = '']) {
-    if (!(valueType(lines) === 'array' || valueType(lines) === 'string') ||
-        valueType(types) !== 'object' || valueType(filename) !== 'string') {
-        return null;
+function schemaParseEx(args) {
+    const [lines, typesArg, filename] = valueArgsValidate(schemaParseExArgs, args);
+    const linesType = valueType(lines);
+    const types = typesArg !== null ? typesArg : {};
+    if (linesType !== 'array' && linesType !== 'string') {
+        throw new ValueArgsError('lines', lines);
     }
 
     return parseSchemaMarkdown(lines, {types, filename});
 }
 
+const schemaParseExArgs = valueArgsModel([
+    {'name': 'lines'},
+    {'name': 'types', 'type': 'object', 'nullable': true},
+    {'name': 'filename', 'type': 'string', 'default': ''}
+]);
+
 
 // $function: schemaTypeModel
 // $group: Schema
@@ -1306,29 +1457,33 @@ function schemaTypeModel() {
 // $arg typeName: The type name
 // $arg value: The object to validate
 // $return: The validated object or null if validation fails
-function schemaValidate([types = null, typeName = null, value = null]) {
-    if (valueType(types) !== 'object' || valueType(typeName) !== 'string') {
-        return null;
-    }
-
+function schemaValidate(args) {
+    const [types, typeName, value] = valueArgsValidate(schemaValidateArgs, args);
     validateTypeModel(types);
     return validateType(types, typeName, value);
 }
 
+const schemaValidateArgs = valueArgsModel([
+    {'name': 'types', 'type': 'object'},
+    {'name': 'typeName', 'type': 'string'},
+    {'name': 'value'}
+]);
+
 
 // $function: schemaValidateTypeModel
 // $group: Schema
 // $doc: Validate a [Schema Markdown Type Model](https://craigahobbs.github.io/schema-markdown-doc/doc/#var.vName='Types')
 // $arg types: The [type model](https://craigahobbs.github.io/schema-markdown-doc/doc/#var.vName='Types') to validate
 // $return: The validated [type model](https://craigahobbs.github.io/schema-markdown-doc/doc/#var.vName='Types')
-function schemaValidateTypeModel([types = null]) {
-    if (valueType(types) !== 'object') {
-        return null;
-    }
-
+function schemaValidateTypeModel(args) {
+    const [types] = valueArgsValidate(schemaValidateTypeModelArgs, args);
     return validateTypeModel(types);
 }
 
+const schemaValidateTypeModelArgs = valueArgsModel([
+    {'name': 'types', 'type': 'object'}
+]);
+
 
 //
 // String functions
@@ -1341,15 +1496,20 @@ function schemaValidateTypeModel([types = null]) {
 // $arg string: The string
 // $arg index: The character index
 // $return: The character code
-function stringCharCodeAt([string = null, index = null]) {
-    if (valueType(string) !== 'string' ||
-        valueType(index) !== 'number' || Math.floor(index) !== index || index < 0 || index >= string.length) {
-        return null;
+function stringCharCodeAt(args) {
+    const [string, index] = valueArgsValidate(stringCharCodeAtArgs, args);
+    if (index >= string.length) {
+        throw new ValueArgsError('index', index);
     }
 
     return string.charCodeAt(index);
 }
 
+const stringCharCodeAtArgs = valueArgsModel([
+    {'name': 'string', 'type': 'string'},
+    {'name': 'index', 'type': 'number', 'integer': true, 'gte': 0}
+]);
+
 
 // $function: stringEndsWith
 // $group: String
@@ -1357,23 +1517,27 @@ function stringCharCodeAt([string = null, index = null]) {
 // $arg string: The string
 // $arg search: The search string
 // $return: true if the string ends with the search string, false otherwise
-function stringEndsWith([string = null, search = null]) {
-    if (valueType(string) !== 'string' || valueType(search) !== 'string') {
-        return null;
-    }
-
+function stringEndsWith(args) {
+    const [string, search] = valueArgsValidate(stringEndsWithArgs, args);
     return string.endsWith(search);
 }
 
+const stringEndsWithArgs = valueArgsModel([
+    {'name': 'string', 'type': 'string'},
+    {'name': 'search', 'type': 'string'}
+]);
+
 
 // $function: stringFromCharCode
 // $group: String
 // $doc: Create a string of characters from character codes
 // $arg charCodes...: The character codes
 // $return: The string of characters
-function stringFromCharCode(charCodes = null) {
-    if (charCodes.some((code) => valueType(code) !== 'number' || Math.floor(code) !== code || code < 0)) {
-        return null;
+function stringFromCharCode(charCodes) {
+    for (const code of charCodes) {
+        if (valueType(code) !== 'number' || Math.floor(code) !== code || code < 0) {
+            throw new ValueArgsError('charCodes', code);
+        }
     }
 
     return String.fromCharCode(...charCodes);
@@ -1387,15 +1551,21 @@ function stringFromCharCode(charCodes = null) {
 // $arg search: The search string
 // $arg index: Optional (default is 0). The index at which to start the search.
 // $return: The first index of the search string; -1 if not found.
-function stringIndexOf([string = null, search = null, index = 0]) {
-    if (valueType(string) !== 'string' || valueType(search) !== 'string' ||
-        valueType(index) !== 'number' || Math.floor(index) !== index || index < 0  || index >= string.length) {
-        return -1;
+function stringIndexOf(args) {
+    const [string, search, index] = valueArgsValidate(stringIndexOfArgs, args, -1);
+    if (index >= string.length) {
+        throw new ValueArgsError('index', index, -1);
     }
 
     return string.indexOf(search, index);
 }
 
+const stringIndexOfArgs = valueArgsModel([
+    {'name': 'string', 'type': 'string'},
+    {'name': 'search', 'type': 'string'},
+    {'name': 'index', 'type': 'number', 'default': 0, 'integer': true, 'gte': 0}
+]);
+
 
 // $function: stringLastIndexOf
 // $group: String
@@ -1404,47 +1574,52 @@ function stringIndexOf([string = null, search = null, index = 0]) {
 // $arg search: The search string
 // $arg index: Optional (default is the end of the string). The index at which to start the search.
 // $return: The last index of the search string; -1 if not found.
-function stringLastIndexOf([string = null, search = null, indexArg = null]) {
-    let index = indexArg;
-    if (index === null && valueType(string) === 'string') {
-        index = string.length - 1;
-    }
-    if (valueType(string) !== 'string' || valueType(search) !== 'string' ||
-        valueType(index) !== 'number' || Math.floor(index) !== index || index < 0  || index >= string.length) {
-        return -1;
+function stringLastIndexOf(args) {
+    const [string, search, indexArg] = valueArgsValidate(stringLastIndexOfArgs, args, -1);
+    const index = indexArg !== null ? indexArg : string.length - 1;
+    if (index >= string.length) {
+        throw new ValueArgsError('index', index, -1);
     }
 
     return string.lastIndexOf(search, index);
 }
 
+const stringLastIndexOfArgs = valueArgsModel([
+    {'name': 'string', 'type': 'string'},
+    {'name': 'search', 'type': 'string'},
+    {'name': 'index', 'type': 'number', 'nullable': true, 'integer': true, 'gte': 0}
+]);
+
 
 // $function: stringLength
 // $group: String
 // $doc: Get the length of a string
 // $arg string: The string
 // $return: The string's length; zero if not a string
-function stringLength([string = null]) {
-    if (valueType(string) !== 'string') {
-        return 0;
-    }
-
+function stringLength(args) {
+    const [string] = valueArgsValidate(stringLengthArgs, args, 0);
     return string.length;
 }
 
+const stringLengthArgs = valueArgsModel([
+    {'name': 'string', 'type': 'string'}
+]);
+
 
 // $function: stringLower
 // $group: String
 // $doc: Convert a string to lower-case
 // $arg string: The string
 // $return: The lower-case string
-function stringLower([string = null]) {
-    if (valueType(string) !== 'string') {
-        return null;
-    }
-
+function stringLower(args) {
+    const [string] = valueArgsValidate(stringLowerArgs, args);
     return string.toLowerCase();
 }
 
+const stringLowerArgs = valueArgsModel([
+    {'name': 'string', 'type': 'string'}
+]);
+
 
 // $function: stringNew
 // $group: String
@@ -1462,14 +1637,16 @@ function stringNew([value = null]) {
 // $arg string: The string to repeat
 // $arg count: The number of times to repeat the string
 // $return: The repeated string
-function stringRepeat([string = null, count = null]) {
-    if (valueType(string) !== 'string' || valueType(count) !== 'number' || Math.floor(count) !== count || count < 0) {
-        return null;
-    }
-
+function stringRepeat(args) {
+    const [string, count] = valueArgsValidate(stringRepeatArgs, args);
     return string.repeat(count);
 }
 
+const stringRepeatArgs = valueArgsModel([
+    {'name': 'string', 'type': 'string'},
+    {'name': 'count', 'type': 'number', 'integer': true, 'gte': 0}
+]);
+
 
 // $function: stringReplace
 // $group: String
@@ -1478,14 +1655,17 @@ function stringRepeat([string = null, count = null]) {
 // $arg substr: The string to replace
 // $arg newSubstr: The replacement string
 // $return: The updated string
-function stringReplace([string = null, substr = null, newSubstr = null]) {
-    if (valueType(string) !== 'string' || valueType(substr) !== 'string' || valueType(newSubstr) !== 'string') {
-        return null;
-    }
-
+function stringReplace(args) {
+    const [string, substr, newSubstr] = valueArgsValidate(stringReplaceArgs, args);
     return string.replaceAll(substr, newSubstr);
 }
 
+const stringReplaceArgs = valueArgsModel([
+    {'name': 'string', 'type': 'string'},
+    {'name': 'substr', 'type': 'string'},
+    {'name': 'newSubstr', 'type': 'string'}
+]);
+
 
 // $function: stringSlice
 // $group: String
@@ -1494,20 +1674,25 @@ function stringReplace([string = null, substr = null, newSubstr = null]) {
 // $arg start: The start index of the slice
 // $arg end: Optional (default is the end of the string). The end index of the slice.
 // $return: The new string slice
-function stringSlice([string = null, begin = null, endArg = null]) {
-    let end = endArg;
-    if (end === null && valueType(string) === 'string') {
-        end = string.length;
+function stringSlice(args) {
+    const [string, start, endArg] = valueArgsValidate(stringSliceArgs, args);
+    const end = endArg !== null ? endArg : string.length;
+    if (start > string.length) {
+        throw new ValueArgsError('start', start);
     }
-    if (valueType(string) !== 'string' ||
-        valueType(begin) !== 'number' || Math.floor(begin) !== begin || begin < 0 || begin > string.length ||
-        valueType(end) !== 'number' || Math.floor(end) !== end || end < 0 || end > string.length) {
-        return null;
+    if (end > string.length) {
+        throw new ValueArgsError('end', end);
     }
 
-    return string.slice(begin, end);
+    return string.slice(start, end);
 }
 
+const stringSliceArgs = valueArgsModel([
+    {'name': 'string', 'type': 'string'},
+    {'name': 'start', 'type': 'number', 'integer': true, 'gte': 0},
+    {'name': 'end', 'type': 'number', 'nullable': true, 'integer': true, 'gte': 0}
+]);
+
 
 // $function: stringSplit
 // $group: String
@@ -1515,14 +1700,16 @@ function stringSlice([string = null, begin = null, endArg = null]) {
 // $arg string: The string to split
 // $arg separator: The separator string
 // $return: The array of split-out strings
-function stringSplit([string = null, separator = null]) {
-    if (valueType(string) !== 'string' || valueType(separator) !== 'string') {
-        return null;
-    }
-
+function stringSplit(args) {
+    const [string, separator] = valueArgsValidate(stringSplitArgs, args);
     return string.split(separator);
 }
 
+const stringSplitArgs = valueArgsModel([
+    {'name': 'string', 'type': 'string'},
+    {'name': 'separator', 'type': 'string'}
+]);
+
 
 // $function: stringStartsWith
 // $group: String
@@ -1530,42 +1717,46 @@ function stringSplit([string = null, separator = null]) {
 // $arg string: The string
 // $arg search: The search string
 // $return: true if the string starts with the search string, false otherwise
-function stringStartsWith([string = null, search = null]) {
-    if (valueType(string) !== 'string' || valueType(search) !== 'string') {
-        return null;
-    }
-
+function stringStartsWith(args) {
+    const [string, search] = valueArgsValidate(stringStartsWithArgs, args);
     return string.startsWith(search);
 }
 
+const stringStartsWithArgs = valueArgsModel([
+    {'name': 'string', 'type': 'string'},
+    {'name': 'search', 'type': 'string'}
+]);
+
 
 // $function: stringTrim
 // $group: String
 // $doc: Trim the whitespace from the beginning and end of a string
 // $arg string: The string
 // $return: The trimmed string
-function stringTrim([string = null]) {
-    if (valueType(string) !== 'string') {
-        return null;
-    }
-
+function stringTrim(args) {
+    const [string] = valueArgsValidate(stringTrimArgs, args);
     return string.trim();
 }
 
+const stringTrimArgs = valueArgsModel([
+    {'name': 'string', 'type': 'string'}
+]);
+
 
 // $function: stringUpper
 // $group: String
 // $doc: Convert a string to upper-case
 // $arg string: The string
 // $return: The upper-case string
-function stringUpper([string = null]) {
-    if (valueType(string) !== 'string') {
-        return null;
-    }
-
+function stringUpper(args) {
+    const [string] = valueArgsValidate(stringUpperArgs, args);
     return string.toUpperCase();
 }
 
+const stringUpperArgs = valueArgsModel([
+    {'name': 'string', 'type': 'string'}
+]);
+
 
 //
 // System functions
@@ -1608,11 +1799,12 @@ async function systemFetch([url = null], options) {
     // Validate the URL argument
     const requests = [];
     let isResponseArray = false;
-    if (valueType(url) === 'string') {
+    const urlType = valueType(url);
+    if (urlType === 'string') {
         requests.push({'url': url});
-    } else if (valueType(url) === 'object') {
+    } else if (urlType === 'object') {
         requests.push(validateType(systemFetchTypes, 'SystemFetchRequest', url));
-    } else if (valueType(url) === 'array') {
+    } else if (urlType === 'array') {
         isResponseArray = true;
         for (const urlItem of url) {
             if (valueType(urlItem) === 'string') {
@@ -1622,7 +1814,7 @@ async function systemFetch([url = null], options) {
             }
         }
     } else {
-        return null;
+        throw new ValueArgsError('url', url);
     }
 
     // Fetch in parallel
@@ -1687,15 +1879,17 @@ struct SystemFetchRequest
 // $arg name: The global variable name
 // $arg defaultValue: The default value (optional)
 // $return: The global variable's value or null if it does not exist
-function systemGlobalGet([name = null, defaultValue = null], options) {
-    if (valueType(name) !== 'string') {
-        return defaultValue;
-    }
-
+function systemGlobalGet(args, options) {
+    const [name, defaultValue] = valueArgsValidate(systemGlobalGetArgs, args);
     const globals = (options !== null ? (options.globals ?? null) : null);
     return globals !== null ? (globals[name] ?? defaultValue) : defaultValue;
 }
 
+const systemGlobalGetArgs = valueArgsModel([
+    {'name': 'name', 'type': 'string'},
+    {'name': 'defaultValue'}
+]);
+
 
 // $function: systemGlobalSet
 // $group: System
@@ -1703,11 +1897,8 @@ function systemGlobalGet([name = null, defaultValue = null], options) {
 // $arg name: The global variable name
 // $arg value: The global variable's value
 // $return: The global variable's value
-function systemGlobalSet([name = null, value = null], options) {
-    if (valueType(name) !== 'string') {
-        return null;
-    }
-
+function systemGlobalSet(args, options) {
+    const [name, value] = valueArgsValidate(systemGlobalSetArgs, args);
     const globals = (options !== null ? (options.globals ?? null) : null);
     if (globals !== null) {
         globals[name] = value;
@@ -1715,6 +1906,11 @@ function systemGlobalSet([name = null, value = null], options) {
     return value;
 }
 
+const systemGlobalSetArgs = valueArgsModel([
+    {'name': 'name', 'type': 'string'},
+    {'name': 'value'}
+]);
+
 
 // $function: systemIs
 // $group: System
@@ -1756,14 +1952,20 @@ function systemLogDebug([message = null], options) {
 // $arg func: The function
 // $arg args...: The function arguments
 // $return: The new function called with "args"
-function systemPartial([func = null, ...args]) {
-    if (valueType(func) !== 'function' || args.length < 1) {
-        return null;
+function systemPartial(args) {
+    const [func, funcArgs] = valueArgsValidate(systemPartialArgs, args);
+    if (funcArgs.length < 1) {
+        throw new ValueArgsError('args', funcArgs);
     }
 
-    return (argsExtra, options) => func([...args, ...argsExtra], options);
+    return (argsExtra, options) => func([...funcArgs, ...argsExtra], options);
 }
 
+const systemPartialArgs = valueArgsModel([
+    {'name': 'func', 'type': 'function'},
+    {'name': 'args', 'lastArgArray': true}
+]);
+
 
 // $function: systemType
 // $group: System
@@ -1787,19 +1989,21 @@ function systemType([value = null]) {
 // $arg url: The URL string
 // $arg extra: Optional (default is true). If true, encode extra characters for wider compatibility.
 // $return: The encoded URL string
-function urlEncode([url = null, extra = true]) {
-    if (valueType(url) !== 'string') {
-        return null;
-    }
-
+function urlEncode(args) {
+    const [url, extra] = valueArgsValidate(urlEncodeArgs, args);
     let urlEncoded = encodeURI(url);
-    if (valueBoolean(extra)) {
+    if (extra) {
         // Replace ')' with '%29' for Markdown links
         urlEncoded = urlEncoded.replaceAll(')', '%29');
     }
     return urlEncoded;
 }
 
+const urlEncodeArgs = valueArgsModel([
+    {'name': 'url', 'type': 'string'},
+    {'name': 'extra', 'type': 'boolean', 'default': true}
+]);
+
 
 // $function: urlEncodeComponent
 // $group: URL
@@ -1807,19 +2011,21 @@ function urlEncode([url = null, extra = true]) {
 // $arg url: The URL component string
 // $arg extra: Optional (default is true). If true, encode extra characters for wider compatibility.
 // $return: The encoded URL component string
-function urlEncodeComponent([url = null, extra = true]) {
-    if (valueType(url) !== 'string') {
-        return null;
-    }
-
+function urlEncodeComponent(args) {
+    const [url, extra] = valueArgsValidate(urlEncodeComponentArgs, args);
     let urlEncoded = encodeURIComponent(url);
-    if (valueBoolean(extra)) {
+    if (extra) {
         // Replace ')' with '%29' for Markdown links
         urlEncoded = urlEncoded.replaceAll(')', '%29');
     }
     return urlEncoded;
 }
 
+const urlEncodeComponentArgs = valueArgsModel([
+    {'name': 'url', 'type': 'string'},
+    {'name': 'extra', 'type': 'boolean', 'default': true}
+]);
+
 
 // The built-in script functions
 export const scriptFunctions = {