tsondb 0.21.4 → 0.21.8

package/dist/src/node/utils/files.js

@@ -1,6 +1,5 @@
 import { readFile, rm, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import {} from "../schema/dsl/index.js";
 import { formatValue } from "../schema/treeOperations/format.js";
 export const getFileNameForId = (id) => `${id}.json`;
 export const getSingletonFileName = (entityName) => `${entityName}.json`;
@@ -20,4 +19,4 @@ export const writeSingletonInstance = (dataRoot, entity, instance, formatterOpti
 });
 export const deleteInstance = (dataRoot, entityName, id) => rm(getPathToInstance(dataRoot, entityName, id));
 export const deleteSingletonInstance = (dataRoot, entityName) => rm(getPathToSingletonInstance(dataRoot, entityName));
-export const formatInstance = (entity, instanceContent, options) => JSON.stringify(formatValue(entity.type.value, instanceContent, {}, options), undefined, 2) + "\n";
+export const formatInstance = (entity, instanceContent, options) => `${JSON.stringify(formatValue(entity.type.value, instanceContent, {}, options), undefined, 2)}\n`;

package/dist/src/node/utils/path.js

@@ -1,2 +1,3 @@
 import { sep } from "node:path";
-export const ensureSpecialDirStart = (path) => new RegExp(`^\\.\\.?\\${sep}`).test(path) ? path : `./${path}`;
+const specialDirStartRegex = new RegExp(`^\\.\\.?\\${sep}`, "u");
+export const ensureSpecialDirStart = (path) => specialDirStartRegex.test(path) ? path : `./${path}`;

package/dist/src/node/utils/references.d.ts

@@ -1,7 +1,7 @@
 import type { SerializedDecl } from "../../shared/schema/declarations/Declaration.ts";
 import type { InstanceContent } from "../../shared/utils/instances.ts";
 import type { AnyEntityMap, GetEntityByName, RegisteredEntityMap } from "../schema/generatedTypeHelpers.ts";
-import { type DatabaseInMemory } from "./databaseInMemory.ts";
+import type { DatabaseInMemory } from "./databaseInMemory.ts";
 /**
  * A mapping from instance IDs to the list of instance IDs that reference them.
  *

package/dist/src/node/utils/references.js

@@ -1,10 +1,9 @@
 import { removeAt } from "@elyukai/utils/array/modify";
 import { difference } from "@elyukai/utils/array/sets";
 import { isOk } from "@elyukai/utils/result";
-import { resolve } from "node:path";
+import { resolve as resolvePath } from "node:path";
 import { getReferencesForSerializedSingletonEntityDecl, } from "../../shared/schema/declarations/SingletonEntityDecl.js";
 import { getReferences } from "../schema/treeOperations/references.js";
-import {} from "./databaseInMemory.js";
 import { WorkerPool } from "./workers.js";
 export const isReferencedByOtherInstances = (referencesToInstances, instanceId, otherInstancesToDelete) => {
     const allInstancesToDelete = [instanceId, ...(otherInstancesToDelete ?? [])];
@@ -17,8 +16,10 @@ const addReference = (acc, reference, instanceId) => ({
 const addReferences = (acc, references, instanceId) => references.reduce((acc1, reference) => addReference(acc1, reference, instanceId), acc);
 const mergeReferences = (acc, toMerge) => {
     for (const instanceId in toMerge) {
-        ;
-        (acc[instanceId] ??= []).push(...(toMerge[instanceId] ?? []));
+        if (Object.hasOwn(toMerge, instanceId)) {
+            ;
+            (acc[instanceId] ??= []).push(...(toMerge[instanceId] ?? []));
+        }
     }
     return acc;
 };
@@ -36,7 +37,7 @@ const removeReference = (acc, reference, instanceId) => {
 };
 const removeReferences = (acc, references, instanceId) => references.reduce((acc1, reference) => removeReference(acc1, reference, instanceId), acc);
 export const getReferencesToInstances = async (databaseInMemory, serializedDeclarationsByName) => {
-    const pool = new WorkerPool(6, resolve(import.meta.dirname, "./referencesWorker.js"), serializedDeclarationsByName);
+    const pool = new WorkerPool(6, resolvePath(import.meta.dirname, "./referencesWorker.js"), serializedDeclarationsByName);
     const separateResults = await Promise.all(databaseInMemory.getAllInstances().map(([entityName, instances]) => new Promise((resolve, reject) => {
         try {
             pool.runTask({ entityName, instances }, result => {

package/dist/src/node/utils/unique.d.ts

@@ -1,7 +1,7 @@
 import { type Result } from "@elyukai/utils/result";
 import type { InstanceContainer, InstanceContainerOverview } from "../../shared/utils/instances.ts";
 import type { EntityDecl } from "../schema/dsl/index.ts";
-import { type DatabaseInMemory } from "./databaseInMemory.ts";
+import type { DatabaseInMemory } from "./databaseInMemory.ts";
 /**
  * Checks all unique constraints for the provided entity and its instances.
  *

package/dist/src/node/utils/unique.js

@@ -4,22 +4,13 @@ import { deepEqual } from "@elyukai/utils/equality";
 import { error, isError, mapError, ok } from "@elyukai/utils/result";
 import { getValueAtKeyPath, getValueAtKeyPathIfDefined, renderKeyPath, } from "../../shared/schema/utils/keyPath.js";
 import { UniqueConstraintError } from "../../shared/utils/unique.js";
-import {} from "./databaseInMemory.js";
 const printUniqueConstraint = (constraint, values) => (Array.isArray(constraint) ? constraint : [constraint])
     .map((elem, i) => "keyPath" in elem
     ? renderKeyPath(elem.keyPath) +
         (elem.keyPathFallback ? "|" + renderKeyPath(elem.keyPathFallback) : "")
-    : renderKeyPath(elem.entityMapKeyPath) +
-        "[" +
-        (Array.isArray(values[i]) ? values[i][0] : "...") +
-        "]." +
-        (elem.keyPathInEntityMapFallback
-            ? "(" +
-                renderKeyPath(elem.keyPathInEntityMap) +
-                "|" +
-                renderKeyPath(elem.keyPathInEntityMapFallback) +
-                ")"
-            : renderKeyPath(elem.keyPathInEntityMap)))
+    : `${renderKeyPath(elem.entityMapKeyPath)}[${Array.isArray(values[i]) ? values[i][0] : "..."}].${elem.keyPathInEntityMapFallback
+        ? `(${renderKeyPath(elem.keyPathInEntityMap)}|${renderKeyPath(elem.keyPathInEntityMapFallback)})`
+        : renderKeyPath(elem.keyPathInEntityMap)}`)
     .join("+");
 /**
  * Checks all unique constraints for the provided entity and its instances.
@@ -28,7 +19,7 @@ const printUniqueConstraint = (constraint, values) => (Array.isArray(constraint)
  * `AggregateError` if there are any violations of any unique constraint.
  */
 export const checkUniqueConstraintsForEntity = (entity, instances, instanceOverviews) => {
-    const constraintErrors = [];
+    const constraintErrorsList = [];
     const constraints = entity.uniqueConstraints ?? [];
     for (const [constraintIndex, constraint] of constraints.entries()) {
         const normalizedConstraint = Array.isArray(constraint) ? constraint : [constraint];
@@ -54,17 +45,17 @@ export const checkUniqueConstraintsForEntity = (entity, instances, instanceOverv
         })).map((row) => [id, row]));
         const duplicates = anySameIndices(index, (a, b) => deepEqual(a[1], b[1]));
         if (duplicates.length > 0) {
-            constraintErrors.push([
+            constraintErrorsList.push([
                 constraintIndex,
                 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- Indices returned by anySameIndices must exist
                 duplicates.map(duplicateSet => duplicateSet.map(rowIndex => index[rowIndex])),
             ]);
         }
     }
-    if (constraintErrors.length > 0) {
-        return error(new AggregateError(constraintErrors.flatMap(([constraintIndex, constraintErrors]) => constraintErrors.map(error => new UniqueConstraintError(
+    if (constraintErrorsList.length > 0) {
+        return error(new AggregateError(constraintErrorsList.flatMap(([constraintIndex, constraintErrors]) => constraintErrors.map(constraintError => new UniqueConstraintError(
         // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- constraint must be present
-        `for unique constraint ${printUniqueConstraint(constraints[constraintIndex], error[0][1])}:`, error.map(row => {
+        `for unique constraint ${printUniqueConstraint(constraints[constraintIndex], constraintError[0][1])}:`, constraintError.map(row => {
             const instanceOverview = instanceOverviews.find(o => o.id === row[0]);
             return instanceOverview ? `"${instanceOverview.displayName}" (${row[0]})` : row[0];
         })))), `in entity "${entity.name}"`));

package/dist/src/shared/schema/declarations/Declaration.d.ts

@@ -2,7 +2,7 @@ import type { BaseNode } from "../Node.ts";
 import type { SerializedTypeParameter } from "../TypeParameter.ts";
 import type { SerializedEnumCaseDecl } from "../types/EnumType.ts";
 import type { SerializedMemberDecl } from "../types/ObjectType.ts";
-import { type SerializedType } from "../types/Type.ts";
+import type { SerializedType } from "../types/Type.ts";
 import type { SerializedEntityDecl } from "./EntityDecl.ts";
 import type { SerializedEnumDecl } from "./EnumDecl.ts";
 import type { SerializedSingletonEntityDecl } from "./SingletonEntityDecl.ts";

package/dist/src/shared/schema/declarations/Declaration.js

@@ -1,4 +1,3 @@
-import {} from "../types/Type.js";
 export const getSerializedTypeArgumentsRecord = (decl, args) => Object.fromEntries(
 // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
 args.slice(0, decl.parameters.length).map((arg, i) => [decl.parameters[i].name, arg]));

package/dist/src/shared/schema/declarations/EnumDecl.js

@@ -1,13 +1,11 @@
 import { NodeKind, } from "../Node.js";
 import { getReferencesForSerializedEnumType, resolveTypeArgumentsInSerializedEnumType, } from "../types/EnumType.js";
 export const isSerializedEnumDecl = (node) => node.kind === NodeKind.EnumDecl;
-export const resolveTypeArgumentsInSerializedEnumDecl = (decls, args, decl) => {
-    return {
-        ...decl,
-        parameters: [],
-        type: resolveTypeArgumentsInSerializedEnumType(decls, args, decl.type),
-    };
-};
+export const resolveTypeArgumentsInSerializedEnumDecl = (decls, args, decl) => ({
+    ...decl,
+    parameters: [],
+    type: resolveTypeArgumentsInSerializedEnumType(decls, args, decl.type),
+});
 export const getReferencesForSerializedEnumDecl = (decls, decl, value) => getReferencesForSerializedEnumType(decls, decl.type, value);
 export const ENUM_DISCRIMINATOR_KEY = "kind";
 export const createEnumCaseValue = (caseName, caseValue) => ({

package/dist/src/shared/schema/types/EnumType.js

@@ -2,11 +2,11 @@ import { ENUM_DISCRIMINATOR_KEY } from "../declarations/EnumDecl.js";
 import { getReferencesSerialized, resolveSerializedTypeArguments, } from "../Node.js";
 export const resolveTypeArgumentsInSerializedEnumType = (decls, args, type) => ({
     ...type,
-    values: Object.fromEntries(Object.entries(type.values).map(([key, { type, ...caseMember }]) => [
+    values: Object.fromEntries(Object.entries(type.values).map(([key, { type: caseType, ...caseMember }]) => [
         key,
         {
             ...caseMember,
-            type: type === null ? null : resolveSerializedTypeArguments(decls, args, type),
+            type: caseType === null ? null : resolveSerializedTypeArguments(decls, args, caseType),
         },
     ])),
 });

package/dist/src/shared/schema/types/NestedEntityMapType.d.ts

@@ -1,5 +1,4 @@
-import type { NodeKind } from "../Node.ts";
-import { type GetReferencesSerialized, type SerializedTypeArgumentsResolver } from "../Node.ts";
+import { type NodeKind, type GetReferencesSerialized, type SerializedTypeArgumentsResolver } from "../Node.ts";
 import { type SerializedIncludeIdentifierType } from "./IncludeIdentifierType.ts";
 import { type SerializedMemberDecl, type SerializedObjectType } from "./ObjectType.ts";
 import type { SerializedBaseType } from "./Type.ts";

package/dist/src/shared/schema/utils/keyPath.js

@@ -1,7 +1,7 @@
 import { isNotEmpty } from "@elyukai/utils/array/nonEmpty";
 import { error, isOk, ok, reduce } from "@elyukai/utils/result";
 import { assertExhaustive, trySafe } from "@elyukai/utils/typeSafety";
-const intPattern = /^(?:0|[1-9][0-9])*$/;
+const intPattern = /^(?:0|[1-9][0-9])*$/u;
 export const parseKeyPath = (keyPath) => normalizeKeyPath(keyPath).map(part => {
     if (intPattern.test(part)) {
         return { kind: "index", index: Number.parseInt(part, 10) };
@@ -26,8 +26,8 @@ export const renderParsedKeyPath = (keyPath) => keyPath
     .join(".");
 export const getAtKeyPath = (value, previousPath, remainingKeyPath, throwOnPathMismatch, fArray, fObject, ...fs) => {
     if (isNotEmpty(remainingKeyPath)) {
-        const [key, ...remainingPath] = remainingKeyPath;
-        const getCaseAtKeyPath = (key, successFn) => reduce(successFn(key, value), newValue => getAtKeyPath(newValue, [...previousPath, key], remainingPath, throwOnPathMismatch, fArray, fObject, ...fs), error => {
+        const [firstKey, ...remainingPath] = remainingKeyPath;
+        const getCaseAtKeyPath = (key, successFn) => reduce(successFn(key, value), newValue => getAtKeyPath(newValue, [...previousPath, key], remainingPath, throwOnPathMismatch, fArray, fObject, ...fs), err => {
             for (const f of fs) {
                 const result = f(value, key);
                 if (isOk(result)) {
@@ -35,32 +35,32 @@ export const getAtKeyPath = (value, previousPath, remainingKeyPath, throwOnPathM
                 }
             }
             if (throwOnPathMismatch) {
-                throw new TypeError(error(renderParsedKeyPath(previousPath)));
+                throw new TypeError(err(renderParsedKeyPath(previousPath)));
             }
             else {
                 return value;
             }
         });
-        switch (key.kind) {
+        switch (firstKey.kind) {
             case "index":
-                return getCaseAtKeyPath(key, (key, value) => fArray(value, key.index));
+                return getCaseAtKeyPath(firstKey, (key, innerValue) => fArray(innerValue, key.index));
             case "property":
-                return getCaseAtKeyPath(key, (key, value) => fObject(value, key.name));
+                return getCaseAtKeyPath(firstKey, (key, innerValue) => fObject(innerValue, key.name));
             default:
-                return assertExhaustive(key);
+                return assertExhaustive(firstKey);
         }
     }
     else {
         return value;
     }
 };
-export const getValueAtKeyPath = (value, keyPath, throwOnPathMismatch = false) => getAtKeyPath(value, [], parseKeyPath(keyPath), throwOnPathMismatch, (value, index) => Array.isArray(value)
-    ? index >= 0 && index < value.length
-        ? ok(value[index])
+export const getValueAtKeyPath = (value, keyPath, throwOnPathMismatch = false) => getAtKeyPath(value, [], parseKeyPath(keyPath), throwOnPathMismatch, (innerValue, index) => Array.isArray(innerValue)
+    ? index >= 0 && index < innerValue.length
+        ? ok(innerValue[index])
         : error(previousPath => `Array at key path "${previousPath}" does not contain the index ${index.toString()}.`)
-    : error(previousPath => `Key path "${previousPath}" does not contain an array.`), (value, name) => typeof value === "object" && value !== null
-    ? name in value
-        ? ok(value[name])
+    : error(previousPath => `Key path "${previousPath}" does not contain an array.`), (innerValue, name) => typeof innerValue === "object" && innerValue !== null
+    ? name in innerValue
+        ? ok(innerValue[name])
         : error(previousPath => `Object at key path "${previousPath}" does not contain the key ${name}.`)
     : error(previousPath => `Key path "${previousPath}" does not contain an object.`));
 export const getValueAtKeyPathIfDefined = (value, keyPath) => trySafe(() => getValueAtKeyPath(value, keyPath, true));

package/dist/src/shared/schema/utils/sortOrder.js

@@ -5,7 +5,7 @@ const getSortOrderValue = (instanceContent, sortOrder) => {
         return getValueAtKeyPath(instanceContent, sortOrder.keyPath);
     }
     else {
-        return;
+        return undefined;
     }
 };
 /**

package/dist/src/shared/utils/git.js

@@ -1,3 +1,4 @@
+import { assertExhaustive } from "@elyukai/utils/typeSafety";
 export const isChangedInIndex = (fileStatus) => {
     const { index } = fileStatus;
     switch (index) {
@@ -14,6 +15,8 @@ export const isChangedInIndex = (fileStatus) => {
         case "?":
         case "!":
             return false;
+        default:
+            return assertExhaustive(index);
     }
 };
 export const isChangedInWorkingDir = (fileStatus) => {
@@ -32,6 +35,8 @@ export const isChangedInWorkingDir = (fileStatus) => {
         case "m":
         case "!":
             return false;
+        default:
+            return assertExhaustive(workingDir);
     }
 };
 const unchangedStatusCodes = new Set([" ", "!", "C", "T", "m", "U"]);
@@ -96,7 +101,7 @@ export const getLabelForGitStatus = (status) => {
             return "";
     }
 };
-const remotePattern = /^remotes\/(\w+?)\/(.+)$/;
+const remotePattern = /^remotes\/(\w+?)\/(.+)$/u;
 export const splitBranchName = (branch) => {
     const [_, remote, actualBranch] = branch.match(remotePattern) ?? ["", undefined, branch];
     return { remote, name: actualBranch };

package/dist/src/shared/utils/render.js

@@ -16,16 +16,16 @@ const mergeArraysByKey = (...arrayGroups) => arrayGroups.reduce((acc, arrayGroup
 export const syntax = (strings, ...values) => strings.reduce((acc, str, i) => {
     const nextValue = values[i];
     if (typeof nextValue === "string") {
-        return [acc[0], acc[1] + str.replace(/\n/g, EOL) + nextValue];
+        return [acc[0], acc[1] + str.replace(/\n/gu, EOL) + nextValue];
     }
     else if (Array.isArray(nextValue)) {
         return [
             mergeArraysByKey(acc[0], nextValue[0]),
-            acc[1] + str.replace(/\n/g, EOL) + nextValue[1],
+            acc[1] + str.replace(/\n/gu, EOL) + nextValue[1],
         ];
     }
     else {
-        return [acc[0], acc[1] + str.replace(/\n/g, EOL)];
+        return [acc[0], acc[1] + str.replace(/\n/gu, EOL)];
     }
 }, emptyRenderResult);
 export const getIndentation = (spaces, indentLevel) => " ".repeat(spaces * indentLevel);

package/dist/src/shared/utils/translation.js

@@ -1,9 +1,8 @@
 import { assertExhaustive } from "@elyukai/utils/typeSafety";
 import { MessageError, parseMessage } from "messageformat";
-const mergeAssoc = (acc, key, value) => {
-    // eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- if there is a previous value and the current result is null, keep the more specific one
-    return { ...acc, [key]: value ?? acc[key] };
-};
+const mergeAssoc = (acc, key, value) => 
+// eslint-disable-next-line @typescript-eslint/no-non-null-assertion -- if there is a previous value and the current result is null, keep the more specific one
+({ ...acc, [key]: value ?? acc[key] });
 const reduceMapAssoc = (map, acc, item) => {
     const result = map(item);
     if (result) {
@@ -26,26 +25,26 @@ const extractParameterFromDeclaration = (decl) => {
     }
 };
 const extractParametersFromDeclarations = (decls) => decls.reduce((acc, decl) => reduceMapAssoc(extractParameterFromDeclaration, acc, decl), {});
-const ignoreLocalVariables = (decls, acc) => decls.reduce((acc, decl) => reduceADT({
-    local: (acc, localDecl) => {
-        const { [localDecl.name]: _, ...rest } = acc;
+const ignoreLocalVariables = (decls, acc) => decls.reduce((acc1, decl) => reduceADT({
+    local: (acc2, localDecl) => {
+        const { [localDecl.name]: _, ...rest } = acc2;
         return rest;
     },
-}, acc, decl), acc);
-const reduceParametersFromPattern = (acc, pattern) => pattern.reduce((acc, element) => {
+}, acc1, decl), acc);
+const reduceParametersFromPattern = (acc, pattern) => pattern.reduce((acc1, element) => {
     if (typeof element === "string") {
-        return acc;
+        return acc1;
     }
     return reduceADT({
-        expression: (acc, element) => {
-            if (!element.arg) {
-                return acc;
+        expression: (acc2, element1) => {
+            if (!element1.arg) {
+                return acc2;
             }
             return reduceADT({
-                variable: (acc, variable) => mergeAssoc(acc, variable.name, element.functionRef?.name ?? null),
-            }, acc, element.arg);
+                variable: (acc3, variable) => mergeAssoc(acc3, variable.name, element1.functionRef?.name ?? null),
+            }, acc2, element1.arg);
         },
-    }, acc, element);
+    }, acc1, element);
 }, acc);
 export const extractParameterTypeNamesFromMessage = (message) => {
     try {

package/dist/src/shared/utils/validation.js

@@ -1,15 +1,15 @@
 import { gte, lte } from "@elyukai/utils/equality";
 export const parallelizeErrors = (errors) => errors.filter(error => error !== undefined);
-const normalizeLabel = (label) => Array.isArray(label) ? label : [label, label + "s"];
+const normalizeLabel = (label) => Array.isArray(label) ? label : [label, `${label}s`];
 export const validateLengthRangeBound = (end, label, rangeBound, value) => {
     if (rangeBound === undefined) {
-        return;
+        return undefined;
     }
     const [operator, description] = end === "lower" ? [gte, "least"] : [lte, "most"];
-    const length = value.length;
+    const { length } = value;
     const normalizedLabel = normalizeLabel(label);
     if (!operator(length, rangeBound)) {
         return RangeError(`expected at ${description} ${rangeBound.toString()} ${normalizedLabel[rangeBound === 1 ? 0 : 1]}, but got ${length.toString()} ${normalizedLabel[length === 1 ? 0 : 1]}`);
     }
-    return;
+    return undefined;
 };

package/dist/src/shared/validation/date.js

@@ -1,6 +1,6 @@
 import { parallelizeErrors } from "../utils/validation.js";
-const datePattern = /^\d{4}-\d{2}-\d{2}$/;
-const dateTimePattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/;
+const datePattern = /^\d{4}-\d{2}-\d{2}$/u;
+const dateTimePattern = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}/u;
 const isValidISODateString = (dateString) => !isNaN(new Date(dateString).getTime());
 export const validateDateConstraints = (constraints, value) => parallelizeErrors([
     constraints.time === true

package/dist/src/shared/validation/identifier.js

@@ -1,5 +1,5 @@
+const localePattern = /^[a-z]{2,3}(-[A-Z]{2,3})?$/u;
 export const validateLocaleIdentifier = (value) => {
-    const localePattern = /^[a-z]{2,3}(-[A-Z]{2,3})?$/;
     if (localePattern.test(value)) {
         return [];
     }

package/dist/src/shared/validation/number.js

@@ -8,7 +8,7 @@ export const validateNumberConstraints = (constraints, value) => parallelizeErro
 const normalizeRangeBound = (rangeBound) => typeof rangeBound === "number" ? { value: rangeBound, isExclusive: false } : rangeBound;
 export const validateRangeBound = (end, rangeBound, value) => {
     if (rangeBound === undefined) {
-        return;
+        return undefined;
     }
     const normalizedRangeBound = normalizeRangeBound(rangeBound);
     const [operator, description] = end === "lower"
@@ -21,7 +21,7 @@ export const validateRangeBound = (end, rangeBound, value) => {
     if (!operator(value, normalizedRangeBound.value)) {
         return RangeError(`expected a value ${description} ${normalizedRangeBound.value.toString()}, but got ${value.toString()}`);
     }
-    return;
+    return undefined;
 };
 export const validateMultipleOf = (multipleOf, value) => {
     if (multipleOf === undefined) {
@@ -30,5 +30,5 @@ export const validateMultipleOf = (multipleOf, value) => {
     if (value % multipleOf !== 0) {
         return RangeError(`expected a value that is a multiple of ${multipleOf.toString()}, but got ${value.toString()}`);
     }
-    return;
+    return undefined;
 };

package/dist/src/shared/validation/object.js

@@ -1,4 +1,4 @@
-import { parallelizeErrors, validateLengthRangeBound } from "../utils/validation.js";
+import { parallelizeErrors, validateLengthRangeBound, } from "../utils/validation.js";
 export const validateObjectConstraints = (constraints, expectedKeys, value) => {
     const actualKeys = Object.keys(value);
     return parallelizeErrors([

package/dist/src/shared/validation/string.js

@@ -13,7 +13,7 @@ export const validateStringConstraints = (constraints, value) => parallelizeErro
             return undefined;
         }
         const pattern = typeof constraints.pattern === "string"
-            ? new RegExp(constraints.pattern)
+            ? new RegExp(constraints.pattern, "u")
             : constraints.pattern;
         return !pattern.test(value)
             ? TypeError(`string does not match the pattern ${pattern.toString()}`)