@aidc-toolkit/utility 0.0.1

package/test/character_set.test.ts

@@ -0,0 +1,170 @@
+import { I18NEnvironment, i18nInit } from "@aidc-toolkit/core";
+import { describe, expect, test } from "vitest";
+import {
+    ALPHABETIC_CREATOR,
+    ALPHANUMERIC_CREATOR,
+    CharacterSetCreator,
+    Exclusion,
+    HEXADECIMAL_CREATOR,
+    IterationHelper,
+    NUMERIC_CREATOR
+} from "../src/index.js";
+
+await i18nInit(I18NEnvironment.CLI, true);
+
+// eslint-disable-next-line jsdoc/require-jsdoc
+function testCharacterSetCreator(name: string, characterSetCreator: CharacterSetCreator, characterSetSize: number, length: number, excludeFirstZero: boolean, excludeAllNumeric: boolean): void {
+    describe(name, () => {
+        test("Character set", () => {
+            characterSetCreator.characterSet.forEach((c, index) => {
+                expect(c).not.toBeUndefined();
+                expect(characterSetCreator.characterIndex(c)).toBe(index);
+            });
+
+            let s = "";
+
+            for (let index = 0; index < characterSetSize; index++) {
+                const c = characterSetCreator.character(index);
+
+                s += c;
+
+                expect(c).not.toBeUndefined();
+                expect(characterSetCreator.characterIndex(c)).toBe(index);
+            }
+
+            expect(characterSetCreator.character(characterSetSize)).toBeUndefined();
+
+            const characterIndexes = characterSetCreator.characterIndexes(s);
+
+            expect(characterIndexes.length).toBe(characterSetSize);
+
+            characterIndexes.forEach((characterIndex, index) => {
+                expect(characterIndex).toBe(index);
+            });
+
+            expect(characterSetCreator.exclusionSupport.includes(Exclusion.FirstZero)).toBe(excludeFirstZero);
+            expect(characterSetCreator.exclusionSupport.includes(Exclusion.AllNumeric)).toBe(excludeAllNumeric);
+        });
+
+        // eslint-disable-next-line jsdoc/require-jsdoc
+        function testCreate(exclusion: Exclusion): void {
+            let domain: number;
+
+            switch (exclusion) {
+                case Exclusion.FirstZero:
+                    expect(() => characterSetCreator.create(0, 0, Exclusion.FirstZero)).toThrow("Domain 0 must be greater than 0");
+                    domain = (characterSetSize - 1) * characterSetSize ** (length - 1);
+                    break;
+
+                case Exclusion.AllNumeric:
+                    expect(() => characterSetCreator.create(0, 0, Exclusion.AllNumeric)).toThrow("Domain 0 must be greater than 0");
+                    domain = characterSetSize ** length - 10 ** length;
+                    break;
+
+                default:
+                    domain = characterSetSize ** length;
+                    break;
+            }
+
+            const sequence = IterationHelper.from(characterSetCreator.createSequence(length, 0n, domain, exclusion));
+
+            let previousS = "";
+
+            let sequenceCount = 0;
+
+            sequence.forEach((s, index) => {
+                expect(s > previousS).toBe(true);
+                previousS = s;
+
+                expect(s.length).toBe(length);
+
+                expect(characterSetCreator.value(s, exclusion)).toBe(BigInt(index));
+
+                sequenceCount++;
+            });
+
+            expect(sequenceCount).toBe(domain);
+
+            expect(() => characterSetCreator.create(length, domain, exclusion)).toThrow(RangeError);
+
+            const sparseSequence = IterationHelper.from(characterSetCreator.createSequence(length, 0n, domain, exclusion, 123456n));
+
+            let sequential = true;
+            previousS = "";
+
+            const sequenceSet = new Set<string>();
+
+            sequenceCount = 0;
+
+            sparseSequence.forEach((s, index) => {
+                sequential = sequential && s > previousS;
+                previousS = s;
+
+                expect(s.length).toBe(length);
+
+                expect(sequenceSet.has(s)).toBe(false);
+                sequenceSet.add(s);
+
+                expect(characterSetCreator.value(s, exclusion, 123456n)).toBe(BigInt(index));
+
+                sequenceCount++;
+            });
+
+            expect(sequential).toBe(false);
+            expect(sequenceCount).toBe(domain);
+
+            const randomValues = new Array<bigint>();
+            const straightRandomValues = new Array<string>();
+            const sparseRandomValues = new Array<string>();
+
+            for (let i = 0; i < 1000; i++) {
+                const randomValue = BigInt(Math.floor(Math.random() * domain));
+
+                randomValues.push(randomValue);
+                straightRandomValues.push(characterSetCreator.create(length, randomValue, exclusion));
+                sparseRandomValues.push(characterSetCreator.create(length, randomValue, exclusion, 123456n));
+            }
+
+            expect(Array.from(characterSetCreator.createMultiple(length, randomValues, exclusion))).toStrictEqual(straightRandomValues);
+            expect(Array.from(characterSetCreator.createMultiple(length, randomValues, exclusion, 123456n))).toStrictEqual(sparseRandomValues);
+
+            expect(() => characterSetCreator.create(length, exclusion, domain, 123456n)).toThrow(RangeError);
+        }
+
+        test("Create sequence", () => {
+            testCreate(Exclusion.None);
+        });
+
+        if (excludeFirstZero) {
+            test("Create sequence, exclude first zero", () => {
+                testCreate(Exclusion.FirstZero);
+
+                expect(() => characterSetCreator.value("0000", Exclusion.FirstZero)).toThrow(RangeError);
+                expect(() => characterSetCreator.value("1000", Exclusion.FirstZero)).not.toThrow(RangeError);
+            });
+        }
+
+        if (excludeAllNumeric) {
+            test("Create sequence, exclude all numeric", () => {
+                testCreate(Exclusion.AllNumeric);
+
+                expect(() => characterSetCreator.value("0000", Exclusion.AllNumeric)).toThrow(RangeError);
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                expect(() => characterSetCreator.value("000" + characterSetCreator.character(characterSetCreator.characterIndex("9")! + 1), Exclusion.AllNumeric)).not.toThrow(RangeError);
+                expect(() => characterSetCreator.value("9999", Exclusion.AllNumeric)).toThrow(RangeError);
+                // eslint-disable-next-line @typescript-eslint/no-non-null-assertion
+                expect(() => characterSetCreator.value("999" + characterSetCreator.character(characterSetCreator.characterIndex("9")! + 1), Exclusion.AllNumeric)).not.toThrow(RangeError);
+            });
+        }
+    });
+}
+
+testCharacterSetCreator("Numeric", NUMERIC_CREATOR, 10, 4, true, false);
+testCharacterSetCreator("Hexadecimal", HEXADECIMAL_CREATOR, 16, 4, true, true);
+testCharacterSetCreator("Alphabetic", ALPHABETIC_CREATOR, 26, 3, false, false);
+testCharacterSetCreator("Alphanumeric", ALPHANUMERIC_CREATOR, 36, 3, true, true);
+testCharacterSetCreator("Middle numeric", new CharacterSetCreator([
+    "(", ")", "*", "+",
+    "0", "1", "2", "3", "4", "5", "6", "7", "8", "9",
+    ":", ";", "<", ">"
+], Exclusion.AllNumeric), 18, 4, false, true);

package/test/iteration.test.ts

@@ -0,0 +1,282 @@
+import { describe, expect, test } from "vitest";
+import { IterationHelper, type IterationSource } from "../src/index.js";
+
+const source: readonly string[] = [
+    "1", "2", "3", "4", "5"
+];
+
+// eslint-disable-next-line jsdoc/require-jsdoc
+function iterableSource(): Iterable<string> {
+    return [...source];
+}
+
+// eslint-disable-next-line jsdoc/require-jsdoc
+function arraySource(): string[] {
+    return [...source];
+}
+
+// eslint-disable-next-line jsdoc/require-jsdoc
+function iteratorSource(): Iterator<string> {
+    return [...source][Symbol.iterator]();
+}
+
+// eslint-disable-next-line jsdoc/require-jsdoc
+function * generatorSource(): Generator<string> {
+    for (const s of source) {
+        yield s;
+    }
+}
+
+// eslint-disable-next-line jsdoc/require-jsdoc
+function callbackSource(): string[] {
+    return [...source];
+}
+
+describe("Iterable", () => {
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    function validateIterable(iterationSource: IterationSource<string>, testEquality: boolean): void {
+        const iterationHelper = IterationHelper.from(iterationSource);
+
+        expect(IterationHelper.from(iterationHelper)).toBe(iterationHelper);
+        expect(iterationHelper.iterationSource).toBe(iterationSource);
+
+        expect(iterationHelper.asIterable() === iterationSource).toBe(testEquality);
+        expect(Array.from(iterationHelper)).toStrictEqual(source);
+    }
+
+    test("Iterable", () => {
+        validateIterable(iterableSource, false);
+        validateIterable(iterableSource(), true);
+    });
+
+    test("Array", () => {
+        validateIterable(arraySource, false);
+        validateIterable(arraySource(), true);
+    });
+
+    test("Iterator", () => {
+        validateIterable(iteratorSource, false);
+        validateIterable(iteratorSource(), true);
+    });
+
+    test("Generator", () => {
+        validateIterable(generatorSource, false);
+        validateIterable(generatorSource(), true);
+    });
+
+    test("Callback", () => {
+        validateIterable(callbackSource, false);
+        validateIterable(callbackSource(), true);
+    });
+});
+
+describe("Array", () => {
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    function validateArray(iterationSource: IterationSource<string>, testEquality: boolean): void {
+        const iterationHelper = IterationHelper.from(iterationSource);
+
+        expect(IterationHelper.from(iterationHelper)).toBe(iterationHelper);
+        expect(iterationHelper.iterationSource).toBe(iterationSource);
+
+        const array = iterationHelper.asArray();
+
+        expect(array === iterationSource).toBe(testEquality);
+        expect(array).toStrictEqual(source);
+    }
+
+    test("Iterable", () => {
+        validateArray(iterableSource, false);
+        validateArray(iterableSource(), true);
+    });
+
+    test("Array", () => {
+        validateArray(arraySource, false);
+        validateArray(arraySource(), true);
+    });
+
+    test("Iterator", () => {
+        validateArray(iteratorSource, false);
+        validateArray(iteratorSource(), false);
+    });
+
+    test("Generator", () => {
+        validateArray(generatorSource, false);
+        validateArray(generatorSource(), false);
+    });
+
+    test("Callback", () => {
+        validateArray(callbackSource, false);
+        validateArray(callbackSource(), true);
+    });
+});
+
+describe("Iterator", () => {
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    function validateIterator(iterationSource: IterationSource<string>, testEquality: boolean): void {
+        const iterationHelper = IterationHelper.from(iterationSource);
+
+        expect(IterationHelper.from(iterationHelper)).toBe(iterationHelper);
+        expect(iterationHelper.iterationSource).toBe(iterationSource);
+
+        const iterator = iterationHelper.asIterator();
+
+        expect(iterator === iterationSource).toBe(testEquality);
+        expect(Array.from({
+            [Symbol.iterator](): Iterator<string> {
+                return iterator;
+            }
+        })).toStrictEqual(source);
+    }
+
+    test("Iterable", () => {
+        validateIterator(iterableSource, false);
+        validateIterator(iterableSource(), false);
+    });
+
+    test("Array", () => {
+        validateIterator(arraySource, false);
+        validateIterator(arraySource(), false);
+    });
+
+    test("Iterator", () => {
+        validateIterator(iteratorSource, false);
+        validateIterator(iteratorSource(), true);
+    });
+
+    test("Generator", () => {
+        validateIterator(generatorSource, false);
+        validateIterator(generatorSource(), true);
+    });
+
+    test("Callback", () => {
+        validateIterator(callbackSource, false);
+        validateIterator(callbackSource(), false);
+    });
+});
+
+describe("Callback", () => {
+    // eslint-disable-next-line jsdoc/require-jsdoc
+    function validateCallback(iterationSource: IterationSource<string>, testEquality: boolean): void {
+        const iterationHelper = IterationHelper.from(iterationSource);
+
+        expect(IterationHelper.from(iterationHelper)).toBe(iterationHelper);
+        expect(iterationHelper.iterationSource).toBe(iterationSource);
+
+        expect(iterationHelper.asCallback() === iterationSource).toBe(testEquality);
+        expect(iterationHelper.asArray()).toStrictEqual(source);
+    }
+
+    test("Iterable", () => {
+        validateCallback(iterableSource, true);
+        validateCallback(iterableSource(), false);
+    });
+
+    test("Array", () => {
+        validateCallback(arraySource, true);
+        validateCallback(arraySource(), false);
+    });
+
+    test("Iterator", () => {
+        validateCallback(iteratorSource, true);
+        validateCallback(iteratorSource(), false);
+    });
+
+    test("Generator", () => {
+        validateCallback(generatorSource, true);
+        validateCallback(generatorSource(), false);
+    });
+
+    test("Callback", () => {
+        validateCallback(callbackSource, true);
+        validateCallback(callbackSource(), false);
+    });
+});
+
+describe("Helpers", () => {
+    test("For each", () => {
+        let count = 0;
+
+        IterationHelper.from(source).forEach((value, index) => {
+            expect(Number(value)).toBe(index + 1);
+            expect(index).toBe(count++);
+        });
+
+        expect(count).toBe(source.length);
+    });
+
+    test("Map", () => {
+        let count = 0;
+
+        const mappedIterationHelper = IterationHelper.from(source).map((element, index) => {
+            expect(Number(element)).toBe(index + 1);
+            expect(index).toBe(count++);
+
+            return -count;
+        });
+
+        expect(count).toBe(0);
+
+        let negativeCount = 0;
+
+        for (const element of mappedIterationHelper) {
+            expect(element).toBe(--negativeCount);
+        }
+
+        expect(count).toBe(source.length);
+    });
+
+    test("Filter", () => {
+        let count = 0;
+
+        const filteredIterable = IterationHelper.from(source).filter((element, index) => {
+            expect(Number(element)).toBe(index + 1);
+            expect(index).toBe(count++);
+
+            return Number(element) % 2 === 0;
+        });
+
+        expect(count).toBe(0);
+
+        let evenCount = 0;
+
+        for (const element of filteredIterable) {
+            const n = Number(element);
+
+            expect(n % 2).toBe(0);
+            expect(Math.floor((n - 1) / 2)).toBe(evenCount++);
+        }
+
+        expect(count).toBe(source.length);
+        expect(evenCount).toBe(Math.floor(source.length / 2));
+    });
+
+    test("Reduce no initial value", () => {
+        let count = 0;
+
+        expect(IterationHelper.from(source).reduce((previousValue, currentValue, currentIndex) => {
+            expect(Number(currentValue)).toBe(currentIndex + 1);
+            expect(currentIndex - 1).toBe(count++);
+
+            return previousValue + currentValue;
+        })).toBe("".concat(...source));
+
+        expect(count).toBe(source.length - 1);
+
+        expect(() => IterationHelper.from<string>([]).reduce(() => "")).toThrow("reduce() of empty iterator with no initial value");
+    });
+
+    test("Reduce initial value", () => {
+        let count = 0;
+
+        expect(IterationHelper.from(source).reduce((previousValue, currentValue, currentIndex) => {
+            expect(Number(currentValue)).toBe(currentIndex + 1);
+            expect(currentIndex).toBe(count++);
+
+            return previousValue + currentValue;
+        }, "0")).toBe("0".concat(...source));
+
+        expect(count).toBe(source.length);
+
+        expect(IterationHelper.from<string>([]).reduce(() => "", "0")).toBe("0");
+    });
+});

package/test/record.test.ts

@@ -0,0 +1,41 @@
+import {I18NEnvironment, i18nInit} from "@aidc-toolkit/core";
+import {describe, expect, test} from "vitest";
+import {RecordValidator} from "../src/index.js";
+
+await i18nInit(I18NEnvironment.CLI, true);
+
+describe("Record validator", () => {
+    enum StringEnum {
+        ValueA = "A",
+        ValueB = "B",
+        ValueC = "C",
+        ValueD = "D"
+    }
+
+    const stringEnumRecord: Record<StringEnum, string> = {
+        [StringEnum.ValueA]: "This is for Value A",
+        [StringEnum.ValueB]: "This is for Value B",
+        [StringEnum.ValueC]: "This is for Value C",
+        [StringEnum.ValueD]: "This is for Value D"
+    };
+
+    test("Validation", () => {
+        const stringEnumRecordValidator = new RecordValidator("String enumeration", stringEnumRecord);
+
+        expect(() => {
+            stringEnumRecordValidator.validate("A");
+        }).not.toThrow(RangeError);
+        expect(() => {
+            stringEnumRecordValidator.validate("B");
+        }).not.toThrow(RangeError);
+        expect(() => {
+            stringEnumRecordValidator.validate("C");
+        }).not.toThrow(RangeError);
+        expect(() => {
+            stringEnumRecordValidator.validate("D");
+        }).not.toThrow(RangeError);
+        expect(() => {
+            stringEnumRecordValidator.validate("E");
+        }).toThrow("String enumeration \"E\" not found");
+    });
+});

package/test/reg_exp.test.ts

@@ -0,0 +1,43 @@
+import {I18NEnvironment, i18nInit} from "@aidc-toolkit/core";
+import {describe, expect, test} from "vitest";
+import {RegExpValidator} from "../src/index.js";
+
+await i18nInit(I18NEnvironment.CLI, true);
+
+describe("Regular expression validator", () => {
+    test("Validation", () => {
+        const anyDigitValidator = new RegExpValidator(/\d+/);
+        const allDigitValidator = new RegExpValidator(/^\d+$/);
+
+        expect(() => {
+            anyDigitValidator.validate("ABC123DEF");
+        }).not.toThrow(RangeError);
+        expect(() => {
+            allDigitValidator.validate("ABC123DEF");
+        }).toThrow("String ABC123DEF does not match pattern");
+
+        expect(() => {
+            anyDigitValidator.validate("1234567890");
+        }).not.toThrow(RangeError);
+        expect(() => {
+            allDigitValidator.validate("1234567890");
+        }).not.toThrow(RangeError);
+
+        expect(() => {
+            anyDigitValidator.validate("123456789O");
+        }).not.toThrow(RangeError);
+        expect(() => {
+            allDigitValidator.validate("123456789O");
+        }).toThrow("String 123456789O does not match pattern");
+    });
+
+    test("Error message", () => {
+        expect(() => {
+            new class extends RegExpValidator {
+                protected override createErrorMessage(s: string): string {
+                    return `Failed to validate "${s}"`;
+                }
+            }(/[A-Z]+/).validate("1234567890");
+        }).toThrow("Failed to validate \"1234567890\"");
+    });
+});

package/test/transformer.test.ts

@@ -0,0 +1,143 @@
+import {I18NEnvironment, i18nInit} from "@aidc-toolkit/core";
+import {describe, expect, test} from "vitest";
+import { EncryptionTransformer, IdentityTransformer, IterationHelper, Transformer } from "../src/index.js";
+
+await i18nInit(I18NEnvironment.CLI, true);
+
+function testTransformer(domain: number, tweak?: number, callback?: (value: bigint, forwardValue: bigint) => void): void {
+    const transformer = Transformer.get(domain, tweak);
+
+    let sequential = true;
+
+    const transformedValuesSet = new Set<bigint>();
+
+    IterationHelper.from(transformer.forwardSequence(0n, domain)).forEach((transformedValue, index) => {
+        const indexN = BigInt(index);
+
+        if (sequential && transformedValue !== indexN) {
+            sequential = false;
+        }
+
+        expect(transformedValuesSet.has(transformedValue)).toBe(false);
+        expect(transformer.reverse(transformedValue)).toBe(indexN);
+
+        transformedValuesSet.add(transformedValue);
+
+        if (callback !== undefined) {
+            callback(indexN, transformedValue);
+        }
+    });
+
+    expect(sequential).toBe(tweak === undefined);
+
+    const randomValues = new Array<bigint>();
+    const transformedRandomValues = new Array<bigint>();
+
+    for (let i = 0; i < 1000; i++) {
+        const randomValue = BigInt(Math.floor(Math.random() * domain));
+
+        randomValues.push(randomValue);
+        transformedRandomValues.push(transformer.forward(randomValue));
+    }
+
+    expect(Array.from(transformer.forwardMultiple(randomValues))).toStrictEqual(transformedRandomValues);
+
+    expect(() => transformer.forward(BigInt(domain))).toThrow(`Value ${domain} must be less than ${domain}`);
+    expect(() => transformer.forwardSequence(BigInt(domain), 0)).not.toThrow(RangeError);
+    expect(() => transformer.forwardSequence(BigInt(domain) - 1n, 1)).not.toThrow(RangeError);
+    expect(() => transformer.forwardSequence(BigInt(domain), 1)).toThrow(`End value (start value + count - 1) ${domain} must be less than ${domain}`);
+}
+
+describe("Identity", () => {
+    test("Get", () => {
+        const transformer = Transformer.get(1000);
+
+        expect(transformer instanceof IdentityTransformer).toBe(true);
+        expect(Transformer.get(1000n)).toBe(transformer);
+
+        expect(transformer.domain).toBe(BigInt(1000n));
+    });
+
+    test("Reversible", () => {
+        const transformer = Transformer.get(25000000n);
+
+        expect(transformer.reverse(transformer.forward(17171717n))).toBe(17171717n);
+    });
+
+    test("Small domain", () => {
+        testTransformer(10);
+    });
+
+    test("Large domain", () => {
+        testTransformer(100000);
+    });
+});
+
+describe("Encryption", () => {
+    test("Get", () => {
+        const transformer = Transformer.get(1000, 1234);
+
+        expect(transformer instanceof EncryptionTransformer).toBe(true);
+        expect(Transformer.get(1000n, 1234n)).toBe(transformer);
+
+        expect(transformer.domain).toBe(BigInt(1000n));
+        expect((transformer as EncryptionTransformer).tweak).toBe(BigInt(1234n));
+
+        const transformer0 = Transformer.get(1000, 0);
+
+        expect(transformer0 instanceof EncryptionTransformer).toBe(true);
+        expect(transformer0).not.toBe(Transformer.get(1000));
+    });
+
+    test("Reversible", () => {
+        const transformer = Transformer.get(25000000n, 12345678901234567890n);
+
+        expect(transformer instanceof EncryptionTransformer).toBe(true);
+        expect(transformer.reverse(transformer.forward(17171717n))).toBe(17171717n);
+    });
+
+    test("Zero domain", () => {
+        expect(() => Transformer.get(0n, 12345678901234567890n)).toThrow("Domain 0 must be greater than 0");
+    });
+
+    test("Zero tweak", () => {
+        const transformer = Transformer.get(1000n, 0n);
+
+        for (let value = 0n; value < 1000n; value++) {
+            expect(transformer.forward(value)).toBe(value);
+        }
+    });
+
+    test("Small domain and tweak", () => {
+        testTransformer(10, 1);
+    });
+
+    test("Large domain and tweak", () => {
+        testTransformer(100000, 123456);
+    });
+
+    test("Byte boundary", () => {
+        // eslint-disable-next-line @typescript-eslint/dot-notation
+        expect((Transformer.get(256n, 1n) as EncryptionTransformer)["_domainBytes"]).toBe(1);
+        // eslint-disable-next-line @typescript-eslint/dot-notation
+        expect((Transformer.get(257n, 1n) as EncryptionTransformer)["_domainBytes"]).toBe(2);
+        // eslint-disable-next-line @typescript-eslint/dot-notation
+        expect((Transformer.get(65536n, 1n) as EncryptionTransformer)["_domainBytes"]).toBe(2);
+        // eslint-disable-next-line @typescript-eslint/dot-notation
+        expect((Transformer.get(65537n, 1n) as EncryptionTransformer)["_domainBytes"]).toBe(3);
+
+        testTransformer(256, 1);
+        testTransformer(257, 1);
+    });
+
+    test("Tweak variation", () => {
+        expect(Array.from(Transformer.get(1000, 1235).forwardSequence(0n, 1000))).not.toStrictEqual(Array.from(Transformer.get(1000, 1234).forwardSequence(0n, 1000)));
+    });
+
+    test("Consistency", () => {
+        expect(Transformer.get(1000n, 1234n).forward(987n)).toBe(35n);
+        expect(Transformer.get(10000n, 12345n).forward(9876n)).toBe(1960n);
+        expect(Transformer.get(100000n, 123456n).forward(98765n)).toBe(21407n);
+        expect(Transformer.get(1000000n, 1234567n).forward(987654n)).toBe(639402n);
+    });
+});

package/tsconfig.json

@@ -0,0 +1,3 @@
+{
+  "extends": "@aidc-toolkit/dev/tsconfig.json"
+}

package/typedoc.json

@@ -0,0 +1,10 @@
+{
+  "$schema": "https://typedoc.org/schema.json",
+  "extends": [
+    "@aidc-toolkit/dev/typedoc.json"
+  ],
+  "name": "Utility",
+  "entryPoints": [
+    "src/index.ts"
+  ]
+}