@deterministic-code/datasources 0.1.1 → 0.1.2

package/dist/UnitOfWorkTransaction.js

@@ -0,0 +1,51 @@
+import { DatasourceError } from "./DatasourceError.js";
+const open = new WeakSet();
+export class UnitOfWorkTransaction {
+    connection;
+    begun = false;
+    transaction;
+    constructor(connection) {
+        this.connection = connection;
+    }
+    begin = async () => {
+        if (this.begun)
+            throw new DatasourceError("Unit of work already begun");
+        this.begun = true;
+        if (open.has(this.connection))
+            return;
+        open.add(this.connection);
+        try {
+            this.transaction = await this.connection.startTransaction();
+        }
+        catch (error) {
+            open.delete(this.connection);
+            throw error;
+        }
+    };
+    commit = async () => {
+        if (!this.begun)
+            throw new DatasourceError("Unit of work has not begun");
+        const txn = this.transaction;
+        if (!txn)
+            return;
+        await txn.commit();
+        this.release();
+    };
+    abort = async () => {
+        if (!this.begun)
+            throw new DatasourceError("Unit of work has not begun");
+        const txn = this.transaction;
+        if (!txn)
+            return;
+        try {
+            await txn.abort();
+        }
+        finally {
+            this.release();
+        }
+    };
+    release() {
+        open.delete(this.connection);
+        this.transaction = undefined;
+    }
+}

package/dist/UpdateEnrichmentStrategy.js

@@ -0,0 +1,61 @@
+import { defaultId } from "./createCRUDRepositoryOptions.js";
+import { DatasourceError } from "./DatasourceError.js";
+import { Operator, Where } from "./statements/index.js";
+export class UpdateEnrichmentStrategy {
+    getCell = (item, name) => item[name];
+    presentCell = (value) => value !== undefined && value !== null && typeof value !== "object" && value !== 0 && value !== 0n && value !== "";
+    payloadOf = (parent, into, enrichment) => mapPayload(this.getCell(parent, into), enrichment);
+    stampCell = (related, by, key) => {
+        if (key === undefined || key === null || typeof key === "object")
+            return;
+        const current = this.getCell(related, by);
+        if (current !== null && typeof current === "object" && !Array.isArray(current)) {
+            const target = current;
+            const id = "Id" in target ? "Id" : "id";
+            target[id] = key;
+            return;
+        }
+        Object.assign(related, { [by]: key });
+    };
+    hasKey = (item, keys) => keys.length > 0 && keys.every((name) => this.presentCell(this.getCell(item, name)));
+    keyOf = (item, keys) => keys.map((name) => String(this.getCell(item, name) ?? "")).join("\u001f");
+    namesOf = (writer, item) => writer.ids.length > 0 ? writer.ids : defaultId(Object.keys(item));
+    linkWhere = (association, parentKey, relatedKey) => new Where(new Operator.And(new Operator.Equals(association.parent, parentKey), new Operator.Equals(association.related, relatedKey)));
+    relatedIds = (parent, enrichment) => {
+        const ids = [];
+        const seen = new Set();
+        for (const related of this.payloadOf(parent, enrichment.destinationProperty)) {
+            const id = this.getCell(related, enrichment.relatedKey);
+            if (!this.presentCell(id))
+                throw new DatasourceError(`${enrichment.destinationProperty} requires "${enrichment.relatedKey}"`);
+            const key = String(id);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            ids.push(id);
+        }
+        return ids;
+    };
+    requiredKey = (parent, enrichment) => {
+        const key = this.getCell(parent, enrichment.sourceProperty);
+        if (!this.presentCell(key))
+            throw new DatasourceError(`${enrichment.destinationProperty} requires "${enrichment.sourceProperty}"`);
+        return key;
+    };
+}
+const mapPayload = (value, enrichment) => {
+    if (value === undefined || value === null || typeof value === "string")
+        return [];
+    if (Array.isArray(value))
+        return value.filter((item) => item !== null && typeof item === "object");
+    if (enrichment?.type !== "dictionary" || typeof value !== "object")
+        return [];
+    const keyName = mapKeyName(enrichment.relatedKey);
+    const valueName = enrichment.relatedProperty ?? (keyName === "Key" ? "Value" : "value");
+    return Object.entries(value)
+        .sort(([left], [right]) => left.localeCompare(right))
+        .map(([key, cell]) => cell !== null && typeof cell === "object" && !Array.isArray(cell)
+        ? { [keyName]: key, ...cell }
+        : { [keyName]: key, [valueName]: cell });
+};
+const mapKeyName = (relatedKey) => relatedKey.includes("_") || relatedKey[0] !== relatedKey[0]?.toUpperCase() ? "key" : "Key";

package/dist/WriteMode.js

@@ -0,0 +1 @@
+export {};

package/dist/builders/Field.js

@@ -0,0 +1 @@
+export {};

package/dist/builders/Scalar.js

@@ -0,0 +1 @@
+export {};

package/dist/builders/index.js

@@ -0,0 +1 @@
+export {};

package/dist/collectAsync.js

@@ -0,0 +1,7 @@
+export async function collectAsync(items) {
+    const collected = [];
+    for await (const item of items) {
+        collected.push(item);
+    }
+    return collected;
+}

package/dist/converters/Cell.js

@@ -0,0 +1 @@
+export {};

package/dist/converters/ChangeCasingConverter.js

@@ -0,0 +1,46 @@
+const cap = (word) => word[0].toUpperCase() + word.slice(1);
+const sep = (c) => c === "_" || c === "." || c === "-" || c === "/" || /\s/.test(c);
+const upper = (c) => c !== c.toLowerCase();
+const lower = (c) => c !== c.toUpperCase();
+const letter = (c) => upper(c) || lower(c);
+const digit = (c) => c >= "0" && c <= "9";
+const words = (text) => {
+    const parts = [];
+    let start = 0;
+    for (let i = 0; i < text.length; i++) {
+        const split = sep(text[i]) ||
+            (i > 0 && lower(text[i - 1]) && upper(text[i])) ||
+            (i > 0 && i + 1 < text.length && upper(text[i - 1]) && upper(text[i]) && lower(text[i + 1])) ||
+            (i > 0 && letter(text[i - 1]) !== letter(text[i]) && (letter(text[i - 1]) || digit(text[i - 1])) && (letter(text[i]) || digit(text[i])));
+        if (!split)
+            continue;
+        if (i > start)
+            parts.push(text.slice(start, i));
+        start = sep(text[i]) ? i + 1 : i;
+    }
+    if (start < text.length)
+        parts.push(text.slice(start));
+    return parts.map((word) => word.toLowerCase()).filter((word) => word.length > 0);
+};
+const join = (parts, casing) => ({
+    camelCase: () => parts.map((word, i) => (i === 0 ? word : cap(word))).join(""),
+    capitalCase: () => parts.map(cap).join(" "),
+    constantCase: () => parts.map((word) => word.toUpperCase()).join("_"),
+    dotCase: () => parts.join("."),
+    kebabCase: () => parts.join("-"),
+    noCase: () => parts.join(" "),
+    pascalCase: () => parts.map(cap).join(""),
+    pascalSnakeCase: () => parts.map(cap).join("_"),
+    pathCase: () => parts.join("/"),
+    sentenceCase: () => parts.map((word, i) => (i === 0 ? cap(word) : word)).join(" "),
+    snakeCase: () => parts.join("_"),
+    trainCase: () => parts.map(cap).join("-"),
+}[casing]());
+export class ChangeCasingConverter {
+    casing;
+    constructor(casing) {
+        this.casing = casing;
+    }
+    convert = (from) => join(words(from), this.casing);
+    reverseConvert = (to) => to;
+}

package/dist/converters/Constructable.js

@@ -0,0 +1 @@
+export {};

package/dist/converters/DefaultValueConverter.d.ts

@@ -0,0 +1,25 @@
+import type { DefaultValueOptions } from "./DefaultValueOptions.js";
+export declare const EMPTY_UUID = "00000000-0000-0000-0000-000000000000";
+export type SpecToken = {
+    spec: RegExp;
+    specText?: (arg: string) => string;
+};
+export type DefaultEntry = SpecToken & {
+    native: (arg: string) => string;
+    reverse: RegExp;
+};
+type DefaultToken = {
+    token: string;
+    arg?: string | boolean;
+};
+export declare const sqlStringLiteral: (value: string | number | boolean | null | undefined) => string;
+export declare class DefaultValueConverter {
+    static readonly spec: Record<string, Record<string, SpecToken>>;
+    readonly dictionary: Record<string, Record<string, DefaultEntry>>;
+    constructor(options: DefaultValueOptions);
+    static parse(specType: string, value: unknown): DefaultToken;
+    convert: (specType: string, text: string) => string | null;
+    reverseConvert: (specType: string, native: string) => string;
+    private static dictionaryOf;
+}
+export {};

package/dist/converters/DefaultValueConverter.js

@@ -0,0 +1,183 @@
+export const EMPTY_UUID = "00000000-0000-0000-0000-000000000000";
+const NUMERIC_LITERAL_TYPES = new Set([
+    "number",
+    "integer",
+    "unsignedinteger",
+    "smallinteger",
+    "unsignedsmallinteger",
+    "biginteger",
+    "unsignedbiginteger",
+    "float",
+    "decimal",
+    "reference",
+]);
+const CALL_FORM = /^([A-Za-z]+)\('(.*)'\)$/;
+const quotedReverse = /^'(.*)'$/;
+const identity = (arg) => arg;
+const intLit = { spec: /^-?[0-9]+$/, specText: identity };
+const uintLit = { spec: /^[0-9]+$/, specText: identity };
+const floatLit = { spec: /^-?[0-9]+(\.[0-9]+)?$/, specText: identity };
+export const sqlStringLiteral = (value) => `'${String(value).replace(/'/g, "''")}'`;
+const escapeRe = (text) => text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+const exact = (text) => new RegExp(`^${escapeRe(text)}$`);
+const quoted = (arg) => sqlStringLiteral(arg);
+const callTokenName = (name) => (name === "uuid" ? "Uuid" : name);
+const token = (specToken, native, reverse) => ({
+    ...specToken,
+    native,
+    reverse,
+});
+const NUMERIC_TYPES = [
+    "number",
+    "integer",
+    "unsignedinteger",
+    "smallinteger",
+    "unsignedsmallinteger",
+    "biginteger",
+    "unsignedbiginteger",
+    "float",
+    "decimal",
+];
+export class DefaultValueConverter {
+    static spec = {
+        string: { String: { spec: /^.*$/, specText: identity } },
+        character: { String: { spec: /^.+$/, specText: identity } },
+        number: { Numeric: intLit },
+        integer: { Numeric: intLit },
+        unsignedinteger: { Numeric: uintLit },
+        smallinteger: { Numeric: intLit },
+        unsignedsmallinteger: { Numeric: uintLit },
+        biginteger: { Numeric: intLit },
+        unsignedbiginteger: { Numeric: uintLit },
+        float: { Numeric: floatLit },
+        decimal: { Numeric: floatLit, String: { spec: /^.*$/, specText: identity } },
+        boolean: { Boolean: { spec: /^(true|false)$/, specText: identity } },
+        datetime: {
+            Now: { spec: /^Now$/ },
+            UtcNow: { spec: /^UtcNow$/ },
+            DateTime: {
+                spec: /^DateTime\('[0-9]{4}-[0-9]{2}-[0-9]{2}T[0-9]{2}:[0-9]{2}:[0-9]{2}(Z|[+-][0-9]{2}:[0-9]{2})'\)$/,
+                specText: (arg) => `DateTime('${arg}')`,
+            },
+        },
+        binary: {
+            Hex: { spec: /^Hex\('([0-9a-fA-F]{2})*'\)$/, specText: (arg) => `Hex('${arg}')` },
+        },
+        uuid: {
+            NewId: { spec: /^NewId$/ },
+            Empty: { spec: /^Empty$/ },
+            Uuid: {
+                spec: /^uuid\('[0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12}'\)$/,
+                specText: (arg) => `uuid('${arg}')`,
+            },
+        },
+        reference: {},
+    };
+    dictionary;
+    constructor(options) {
+        this.dictionary = DefaultValueConverter.dictionaryOf(options);
+    }
+    static parse(specType, value) {
+        if (value === undefined || value === null)
+            return { token: "None" };
+        const v = String(value);
+        const call = CALL_FORM.exec(v);
+        if (call !== null)
+            return { token: callTokenName(call[1]), arg: call[2] };
+        if (specType === "boolean") {
+            return { token: "Boolean", arg: typeof value === "boolean" ? value : v === "true" };
+        }
+        if (NUMERIC_LITERAL_TYPES.has(specType))
+            return { token: "Numeric", arg: v };
+        if (specType === "datetime") {
+            if (v === "Now")
+                return { token: "Now" };
+            if (v === "UtcNow")
+                return { token: "UtcNow" };
+            return { token: "DateTime", arg: v };
+        }
+        if (specType === "uuid") {
+            if (v === "NewId")
+                return { token: "NewId" };
+            if (v === "Empty")
+                return { token: "Empty" };
+            return { token: "Uuid", arg: v };
+        }
+        if (specType === "binary")
+            return { token: "Hex", arg: v };
+        return { token: "String", arg: v };
+    }
+    convert = (specType, text) => {
+        const parsed = DefaultValueConverter.parse(specType, text);
+        if (parsed.token === "None")
+            return null;
+        const entries = this.dictionary[specType];
+        if (entries === undefined)
+            throw new Error(`Unknown spec field type: ${specType}`);
+        const entry = entries[parsed.token];
+        if (entry === undefined)
+            return null;
+        if (!entry.spec.test(text)) {
+            throw new Error(`default_value '${text}' is not a valid ${specType} ${parsed.token} default`);
+        }
+        const expr = entry.native(parsed.arg === undefined ? "" : String(parsed.arg));
+        return expr === "" ? null : expr;
+    };
+    reverseConvert = (specType, native) => {
+        const entries = this.dictionary[specType];
+        if (entries === undefined)
+            throw new Error(`Unknown spec field type: ${specType}`);
+        for (const [name, entry] of Object.entries(entries)) {
+            const match = entry.reverse.exec(native);
+            if (match === null)
+                continue;
+            const arg = match[1] ?? "";
+            return entry.specText === undefined ? name : entry.specText(arg);
+        }
+        throw new Error(`Native default '${native}' is not a valid ${specType} default`);
+    };
+    static dictionaryOf = (opts) => {
+        const spec = DefaultValueConverter.spec;
+        const newId = opts.newId();
+        const now = opts.now();
+        const utcNow = opts.utcNow();
+        const numericEntries = (type) => {
+            const numeric = spec[type].Numeric;
+            return {
+                Numeric: token(numeric, (arg) => arg, numeric.spec),
+                String: token(numeric, (arg) => arg, numeric.spec),
+            };
+        };
+        const quotedString = {
+            String: token(spec.string.String, quoted, quotedReverse),
+            Numeric: token(spec.string.String, quoted, quotedReverse),
+        };
+        const dictionary = {
+            string: quotedString,
+            character: {
+                String: token(spec.character.String, quoted, quotedReverse),
+                Numeric: token(spec.character.String, quoted, quotedReverse),
+            },
+            boolean: {
+                Boolean: token(spec.boolean.Boolean, (arg) => (arg === "true" ? opts.booleanOn : opts.booleanOff), new RegExp(`^(${escapeRe(opts.booleanOn)}|${escapeRe(opts.booleanOff)})$`)),
+            },
+            datetime: {
+                Now: token(spec.datetime.Now, () => now, exact(now)),
+                UtcNow: token(spec.datetime.UtcNow, () => utcNow, exact(utcNow)),
+                DateTime: token(spec.datetime.DateTime, quoted, quotedReverse),
+            },
+            binary: {
+                Hex: token(spec.binary.Hex, opts.hex, opts.hexReverse),
+            },
+            uuid: {
+                NewId: token(spec.uuid.NewId, () => newId, exact(newId)),
+                Empty: token(spec.uuid.Empty, () => quoted(EMPTY_UUID), exact(quoted(EMPTY_UUID))),
+                Uuid: token(spec.uuid.Uuid, quoted, quotedReverse),
+            },
+            reference: {},
+        };
+        for (const type of NUMERIC_TYPES)
+            dictionary[type] = numericEntries(type);
+        return dictionary;
+    };
+}

package/dist/converters/DefaultValueOptions.d.ts

@@ -0,0 +1,9 @@
+export type DefaultValueOptions = {
+    newId: () => string;
+    now: () => string;
+    utcNow: () => string;
+    booleanOn: string;
+    booleanOff: string;
+    hex: (arg: string) => string;
+    hexReverse: RegExp;
+};

package/dist/converters/DefaultValueOptions.js

@@ -0,0 +1 @@
+export {};

package/dist/converters/DeterministicTypeConverter.d.ts

@@ -0,0 +1,11 @@
+import type { IMapping } from "./IMapping.js";
+import { type SpecField } from "./SpecField.js";
+import type { SpecFieldRules } from "./SpecFieldRules.js";
+export declare class DeterministicTypeConverter implements IMapping<string, string> {
+    #private;
+    readonly dictionary: Record<string, string>;
+    constructor(dictionary: Record<string, string>, rules: SpecFieldRules);
+    convert(from: string): string;
+    convert(from: SpecField): string;
+    reverseConvert: (native: string) => string;
+}

package/dist/converters/DeterministicTypeConverter.js

@@ -0,0 +1,74 @@
+const isUnlimited = (size) => size === "unlimited" || size === undefined || size === null;
+const sized = (unlimited, render, field) => isUnlimited(field.size) ? unlimited : render(Number(field.size));
+const charLen = (field) => field.size === undefined || field.size === null ? 1 : Number(field.size);
+const decimalPrecisionScale = (field) => {
+    const s = field.size;
+    if (Array.isArray(s) && s.length === 2) {
+        const [p, sc] = s;
+        if (!Number.isInteger(p) || !Number.isInteger(sc)) {
+            throw new Error(`decimal field "${field.name}" size must be [precision, scale] integers; got ${JSON.stringify(s)}`);
+        }
+        return [p, sc];
+    }
+    if (s === undefined || s === null)
+        return null;
+    throw new Error(`decimal field "${field.name}" size must be [precision, scale] tuple; got ${JSON.stringify(s)}`);
+};
+export class DeterministicTypeConverter {
+    dictionary;
+    #reverse;
+    #rules;
+    constructor(dictionary, rules) {
+        this.dictionary = dictionary;
+        this.#rules = rules;
+        this.#reverse = new Map();
+        for (const [specType, native] of Object.entries(dictionary)) {
+            const existing = this.#reverse.get(native);
+            if (existing === undefined)
+                this.#reverse.set(native, [specType]);
+            else
+                existing.push(specType);
+        }
+    }
+    convert(from) {
+        if (typeof from === "string") {
+            const native = this.dictionary[from];
+            if (native === undefined)
+                throw new Error(`Unknown spec field type: ${from}`);
+            return native;
+        }
+        const field = from;
+        const row = this.#rules;
+        if (field.type === "string")
+            return sized(row.stringUnlimited, row.stringSized, field);
+        if (field.type === "character" && row.character !== undefined) {
+            return `${row.character}(${charLen(field)})`;
+        }
+        if (field.type === "decimal" && row.decimal !== undefined) {
+            const rule = row.decimal;
+            const ps = decimalPrecisionScale(field);
+            if (rule.kind === "required") {
+                if (!ps) {
+                    throw new Error(`decimal field "${field.name}" requires size: [precision, scale] for ${row.dialectName ?? "sql"}`);
+                }
+                return `${rule.type}(${ps[0]}, ${ps[1]})`;
+            }
+            return ps ? `${rule.type}(${ps[0]}, ${ps[1]})` : rule.fallback;
+        }
+        if (field.type === "binary") {
+            if (row.binarySized !== undefined && row.binaryUnlimited !== undefined) {
+                return sized(row.binaryUnlimited, row.binarySized, field);
+            }
+        }
+        return this.convert(field.type);
+    }
+    reverseConvert = (native) => {
+        const specTypes = this.#reverse.get(native);
+        if (specTypes === undefined)
+            throw new Error(`Unknown native field type: ${native}`);
+        if (specTypes.length > 1) {
+            throw new Error(`Native field type ${native} maps to multiple spec types: ${specTypes.join(", ")}`);
+        }
+        return specTypes[0];
+    };
+}

package/dist/converters/IMapping.d.ts

@@ -0,0 +1,4 @@
+export interface IMapping<TFrom, TTo> {
+    convert(from: TFrom): TTo;
+    reverseConvert(to: TTo): TFrom;
+}

package/dist/converters/IMapping.js

@@ -0,0 +1 @@
+export {};

package/dist/converters/MetaDataRowTypeConverter.js

@@ -0,0 +1,71 @@
+import { TypeConverter } from "./TypeConverter.js";
+import { IdentityMapper } from "../mappers/IdentityMapper.js";
+const scalarId = (value) => {
+    if (value === undefined || value === null || typeof value !== "object" || value instanceof Date || value instanceof Uint8Array)
+        return value === undefined ? undefined : value;
+    const record = value;
+    return record.Id !== undefined ? record.Id : record.id;
+};
+export class MetaDataRowTypeConverter extends TypeConverter {
+    fields;
+    references = new Set();
+    referenceColumns = new IdentityMapper();
+    shouldCoerceId = false;
+    constructor(fields = {}) {
+        super();
+        this.fields = { ...fields };
+    }
+    convert = (row, type) => {
+        const blank = type ? new type() : {};
+        const cells = Object.fromEntries(Object.entries(row).filter(([key, value]) => {
+            if (this.references.has(key))
+                return false;
+            const current = blank[key];
+            return !(typeof current === "string" && typeof value !== "string" && value !== null);
+        }));
+        const dest = Object.assign(blank, cells);
+        const record = dest;
+        for (const [key, value] of Object.entries(row)) {
+            if (this.references.has(key)) {
+                const current = record[key];
+                const target = current !== null && typeof current === "object" && !Array.isArray(current)
+                    ? current
+                    : {};
+                const id = "Id" in target ? "Id" : "id";
+                target[id] = value;
+                record[key] = target;
+                continue;
+            }
+            const converter = this.fields[key];
+            if (converter)
+                record[key] = converter.convert(value);
+        }
+        return dest;
+    };
+    reverseConvert = (row) => {
+        const cells = {};
+        for (const [key, value] of Object.entries(row)) {
+            if (Array.isArray(value))
+                continue;
+            if (value !== null &&
+                typeof value === "object" &&
+                !(value instanceof Date) &&
+                !(value instanceof Uint8Array) &&
+                !this.references.has(key))
+                continue;
+            if (this.references.has(key)) {
+                const id = scalarId(value);
+                if (id !== undefined && id !== null)
+                    cells[this.referenceColumns.map(key)] = this.converted(key, id);
+                continue;
+            }
+            const converter = this.fields[key];
+            cells[key] = converter ? converter.reverseConvert(value) : value;
+        }
+        return cells;
+    };
+    converted = (key, value) => {
+        const converter = this.fields[key];
+        return converter ? converter.reverseConvert(value) : value;
+    };
+}

package/dist/converters/PluralizerConverter.js

@@ -0,0 +1,54 @@
+const uncountable = new Set(["sheep", "fish", "series", "species", "deer", "news"]);
+const irregular = {
+    person: "people",
+    child: "children",
+    man: "men",
+    woman: "women",
+    mouse: "mice",
+    goose: "geese",
+    tooth: "teeth",
+    foot: "feet",
+    ox: "oxen",
+};
+const irregularSingular = Object.fromEntries(Object.entries(irregular).map(([singular, plural]) => [plural, singular]));
+const vowel = (c) => "aeiou".includes(c);
+const consonant = (c) => /[a-z]/.test(c) && !vowel(c);
+const yies = (word) => word.length >= 4 && word.endsWith("ies") && consonant(word[word.length - 4]);
+const consonantY = (word) => word.length >= 2 && word.endsWith("y") && consonant(word[word.length - 2]);
+const sibilant = (word) => word.endsWith("ch") ||
+    word.endsWith("sh") ||
+    word.endsWith("x") ||
+    word.endsWith("z") ||
+    word.endsWith("ss") ||
+    (word.length >= 2 && word.endsWith("s") && !word.endsWith("es") && vowel(word[word.length - 2]));
+const sibilantEs = (word) => word.length > 2 && word.endsWith("es") && sibilant(word.slice(0, -2));
+const restore = (original, result) => original[0] === original[0].toUpperCase()
+    ? result[0].toUpperCase() + result.slice(1)
+    : result;
+const plural = (word) => uncountable.has(word) || word in irregularSingular
+    ? word
+    : irregular[word] ??
+        (yies(word) || sibilantEs(word)
+            ? word
+            : sibilant(word)
+                ? word + "es"
+                : consonantY(word)
+                    ? word.slice(0, -1) + "ies"
+                    : word.endsWith("s")
+                        ? word
+                        : word + "s");
+const singular = (word) => uncountable.has(word) || word in irregular
+    ? word
+    : (irregularSingular[word] ??
+        (yies(word)
+            ? word.slice(0, -3) + "y"
+            : sibilantEs(word)
+                ? word.slice(0, -2)
+                : word.endsWith("s") && !sibilant(word)
+                    ? word.slice(0, -1)
+                    : word));
+const apply = (word, transform) => word.length === 0 ? word : restore(word, transform(word.toLowerCase()));
+export class PluralizerConverter {
+    convert = (from) => apply(from, plural);
+    reverseConvert = (to) => apply(to, singular);
+}

package/dist/converters/RegexConverter.js

@@ -0,0 +1,12 @@
+export class RegexConverter {
+    regex;
+    replacement;
+    constructor(pattern, replacement) {
+        this.regex = typeof pattern === "string"
+            ? new RegExp(pattern, "g")
+            : new RegExp(pattern.source, pattern.flags.includes("g") ? pattern.flags : `${pattern.flags}g`);
+        this.replacement = replacement;
+    }
+    convert = (from) => from.replace(this.regex, this.replacement);
+    reverseConvert = (to) => to;
+}

package/dist/converters/ReplaceConverter.js

@@ -0,0 +1,10 @@
+export class ReplaceConverter {
+    search;
+    replacement;
+    constructor(search, replacement) {
+        this.search = search;
+        this.replacement = replacement;
+    }
+    convert = (from) => from.replaceAll(this.search, this.replacement);
+    reverseConvert = (to) => to.replaceAll(this.replacement, this.search);
+}