functionalscript 0.6.6 → 0.6.8

package/README.md

@@ -21,6 +21,31 @@ Learn more about
 
 This repository is a [monorepo](https://en.wikipedia.org/wiki/Monorepo) and distributted under [AGPL-3.0](https://www.gnu.org/licenses/agpl-3.0.en.html#license-text). Let us know if you need another license by sending an [email](mailto:sergey.oss@proton.me).
 
+## Getting Started
+
+Install FunctionalScript via npm:
+
+```bash
+npm install functionalscript
+```
+
+The FunctionalScript compiler (`fsc`) currently supports:
+
+* `import` statements
+* `const` declarations
+
+It does **not** yet support functions or complex expressions.
+
+Example usage with `fsc`:
+
+```bash
+npx fsc example.f.js output.json
+# or
+npx fsc example.f.js output.f.js
+```
+
+FunctionalScript code can be compiled directly into either JSON or JavaScript without imports.
+
 ## Vision
 
 We aim to create a safe, cross-platform programming language that can work in any JS platform without any build step. There are thousands of programming languages, and we don't want to create another one that others must learn. Instead, we take the opposite approach: we remove everything that makes the most popular and cross-platform language unsafe, insecure, or less portable.

package/djs/ast/test.f.js

@@ -1,39 +1,39 @@
 import * as list from "../../types/object/module.f.js";
 const { sort } = list;
 import * as shared from "./module.f.js";
-import { stringify } from "../serializer/module.f.js";
+import { stringifyAsTree } from "../serializer/module.f.js";
 export default {
     test: () => {
         const djs = shared.run([1])([]);
-        const result = stringify(sort)(djs);
+        const result = stringifyAsTree(sort)(djs);
         if (result !== '1') {
             throw result;
         }
     },
     testCref: () => {
         const djs = shared.run([1, 2, 3, 4, 5, ['cref', 3]])([11, 12, 13, 14, 15]);
-        const result = stringify(sort)(djs);
+        const result = stringifyAsTree(sort)(djs);
         if (result !== '4') {
             throw result;
         }
     },
     testAref: () => {
         const djs = shared.run([1, 2, 3, 4, 5, ['aref', 3]])([11, 12, 13, 14, 15]);
-        const result = stringify(sort)(djs);
+        const result = stringifyAsTree(sort)(djs);
         if (result !== '14') {
             throw result;
         }
     },
     testArray: () => {
         const djs = shared.run([1, 2, 3, 4, 5, ['array', [['aref', 3], ['cref', 3]]]])([11, 12, 13, 14, 15]);
-        const result = stringify(sort)(djs);
+        const result = stringifyAsTree(sort)(djs);
         if (result !== '[14,4]') {
             throw result;
         }
     },
     testObj: () => {
         const djs = shared.run([1, 2, 3, 4, 5, { "key": { "key2": ['array', [['aref', 3], ['cref', 3]]] } }])([11, 12, 13, 14, 15]);
-        const result = stringify(sort)(djs);
+        const result = stringifyAsTree(sort)(djs);
         if (result !== '{"key":{"key2":[14,4]}}') {
             throw result;
         }

package/djs/module.f.js

@@ -1,7 +1,6 @@
 import { transpile } from "./transpiler/module.f.js";
-import { stringify } from "./serializer/module.f.js";
+import { stringify, stringifyAsTree } from "./serializer/module.f.js";
 import { sort } from "../types/object/module.f.js";
-const stringifyUnknown = stringify(sort);
 export const compile = ({ console: { error }, fs, process: { argv } }) => {
     const args = argv.slice(2);
     if (args.length < 2) {
@@ -13,7 +12,12 @@ export const compile = ({ console: { error }, fs, process: { argv } }) => {
     const result = transpile(fs)(inputFileName);
     switch (result[0]) {
         case 'ok': {
-            const output = stringifyUnknown(result[1]);
+            if (outputFileName.endsWith('.json')) {
+                const output = stringifyAsTree(sort)(result[1]);
+                fs.writeFileSync(outputFileName, output);
+                break;
+            }
+            const output = stringify(sort)(result[1]);
             fs.writeFileSync(outputFileName, output);
             break;
         }

package/djs/parser/module.f.js

@@ -16,7 +16,7 @@ const parseInitialOp = token => state => {
             }
         }
     }
-    return { state: 'error', message: 'unexpected token' };
+    return foldOp(token)({ ...state, state: 'exportValue', valueState: '', top: null, stack: null });
 };
 const parseNewLineRequiredOp = token => state => {
     switch (token.kind) {

package/djs/parser/test.f.d.ts

@@ -2,6 +2,7 @@ declare const _default: {
     valid: (() => void)[];
     invalid: (() => void)[];
     validWhiteSpaces: (() => void)[];
+    validJson: (() => void)[];
     invalidModule: (() => void)[];
     validWithConst: (() => void)[];
     invalidWithConst: (() => void)[];

package/djs/parser/test.f.js

@@ -3,9 +3,9 @@ import * as tokenizer from "../tokenizer/module.f.js";
 import { toArray } from "../../types/list/module.f.js";
 import { sort } from "../../types/object/module.f.js";
 import * as encoding from "../../text/utf16/module.f.js";
-import { stringify } from "../serializer/module.f.js";
+import { stringifyAsTree } from "../serializer/module.f.js";
 const tokenizeString = s => toArray(tokenizer.tokenize(encoding.stringToList(s)));
-const stringifyDjsModule = stringify(sort);
+const stringifyDjsModule = stringifyAsTree(sort);
 export default {
     valid: [
         () => {
@@ -484,24 +484,60 @@ export default {
             }
         },
     ],
-    invalidModule: [
+    validJson: [
         () => {
             const tokenList = tokenizeString('null');
             const obj = parser.parseFromTokens(tokenList);
-            if (obj[0] !== 'error') {
+            if (obj[0] !== 'ok') {
                 throw obj;
             }
-            if (obj[1] !== 'unexpected token') {
+            const result = stringifyDjsModule(obj[1]);
+            if (result !== '[[],[null]]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('1');
+            const obj = parser.parseFromTokens(tokenList);
+            if (obj[0] !== 'ok') {
                 throw obj;
             }
+            const result = stringifyDjsModule(obj[1]);
+            if (result !== '[[],[1]]') {
+                throw result;
+            }
         },
+        () => {
+            const tokenList = tokenizeString('[]');
+            const obj = parser.parseFromTokens(tokenList);
+            if (obj[0] !== 'ok') {
+                throw obj;
+            }
+            const result = stringifyDjsModule(obj[1]);
+            if (result !== '[[],[["array",[]]]]') {
+                throw result;
+            }
+        },
+        () => {
+            const tokenList = tokenizeString('{"valid":"json"}');
+            const obj = parser.parseFromTokens(tokenList);
+            if (obj[0] !== 'ok') {
+                throw obj;
+            }
+            const result = stringifyDjsModule(obj[1]);
+            if (result !== '[[],[{"valid":"json"}]]') {
+                throw result;
+            }
+        }
+    ],
+    invalidModule: [
         () => {
             const tokenList = tokenizeString('module=null');
             const obj = parser.parseFromTokens(tokenList);
             if (obj[0] !== 'error') {
                 throw obj;
             }
-            if (obj[1] !== 'unexpected token') {
+            if (obj[1] !== 'const not found') {
                 throw obj;
             }
         },

package/djs/serializer/module.f.d.ts

@@ -1,13 +1,14 @@
-import * as list from '../../types/list/module.f.ts';
+import type * as djs from '../module.f.ts';
 import type * as O from '../../types/object/module.f.ts';
-import type { Unknown } from '../module.f.ts';
-type Entry = O.Entry<Unknown>;
-type Entries = list.List<Entry>;
+import { type List } from '../../types/list/module.f.ts';
+export declare const undefinedSerialize: string[];
+type RefCounter = [number, number, boolean];
+type Entry = O.Entry<djs.Unknown>;
+type Entries = List<Entry>;
 type MapEntries = (entries: Entries) => Entries;
-export declare const serialize: (mapEntries: MapEntries) => (value: Unknown) => list.List<string>;
-/**
- * The standard `JSON.stringify` rules determined by
- * https://262.ecma-international.org/6.0/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys
- */
-export declare const stringify: (mapEntries: MapEntries) => (value: Unknown) => string;
+type Refs = Map<djs.Unknown, RefCounter>;
+export declare const serializeWithoutConst: (mapEntries: MapEntries) => (value: djs.Unknown) => List<string>;
+export declare const stringify: (sort: MapEntries) => (djs: djs.Unknown) => string;
+export declare const stringifyAsTree: (mapEntries: MapEntries) => (value: djs.Unknown) => string;
+export declare const countRefs: (djs: djs.Unknown) => Refs;
 export {};

package/djs/serializer/module.f.js

@@ -1,17 +1,54 @@
-import * as list from "../../types/list/module.f.js";
-const { flat, map } = list;
+import { fold } from "../../types/list/module.f.js";
 import * as string from "../../types/string/module.f.js";
 const { concat } = string;
+import { flat, flatMap, map, concat as listConcat } from "../../types/list/module.f.js";
+const { entries } = Object;
 import * as f from "../../types/function/module.f.js";
 const { compose, fn } = f;
-const { entries } = Object;
-import * as bi from "../../types/bigint/module.f.js";
-const { serialize: bigintSerialize } = bi;
-import * as j from "../../json/serializer/module.f.js";
-const { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } = j;
+import { serialize as bigintSerialize } from "../../types/bigint/module.f.js";
+import * as serializer from "../../json/serializer/module.f.js";
+const { objectWrap, arrayWrap, stringSerialize, numberSerialize, nullSerialize, boolSerialize } = serializer;
 const colon = [':'];
-const undefinedSerialize = ['undefined'];
-export const serialize = sort => {
+export const undefinedSerialize = ['undefined'];
+const getConstantsOp = djs => state => {
+    switch (typeof djs) {
+        case 'boolean': {
+            return state;
+        }
+        case 'number':
+        case 'string':
+        case 'bigint': {
+            return getConstantSelf(djs)(state);
+        }
+        default: {
+            if (djs === null) {
+                return state;
+            }
+            if (djs === undefined) {
+                return state;
+            }
+            if (djs instanceof Array) {
+                return getConstantSelf(djs)(fold(getConstantsOp)(state)(djs));
+            }
+            return getConstantSelf(djs)(fold(getConstantsOp)(state)(map(entryValue)(entries(djs))));
+        }
+    }
+};
+const getConstantSelf = djs => state => {
+    const refs = state.refs;
+    const refCounter = refs.get(djs);
+    if (refCounter !== undefined && refCounter[1] > 1 && !refCounter[2]) {
+        refCounter[2] = true;
+        refs.set(djs, refCounter);
+        return { refs, consts: { head: state.consts, tail: [djs] } };
+    }
+    return state;
+};
+const getConstants = djs => refs => {
+    return getConstantsOp(djs)(refs);
+};
+const entryValue = kv => kv[1];
+export const serializeWithoutConst = sort => {
     const propertySerialize = ([k, v]) => flat([
         stringSerialize(k),
         colon,
@@ -54,8 +91,105 @@ export const serialize = sort => {
     const arraySerialize = compose(map(f))(arrayWrap);
     return f;
 };
-/**
- * The standard `JSON.stringify` rules determined by
- * https://262.ecma-international.org/6.0/#sec-ordinary-object-internal-methods-and-internal-slots-ownpropertykeys
- */
-export const stringify = sort => compose(serialize(sort))(concat);
+const serializeWithConst = sort => refs => root => {
+    const propertySerialize = ([k, v]) => flat([
+        stringSerialize(k),
+        colon,
+        f(v)
+    ]);
+    const mapPropertySerialize = map(propertySerialize);
+    const objectSerialize = fn(entries)
+        .then(sort)
+        .then(mapPropertySerialize)
+        .then(objectWrap)
+        .result;
+    const f = value => {
+        if (value !== root) {
+            const refCounter = refs.get(value);
+            if (refCounter !== undefined && refCounter[1] > 1) {
+                return [`c${refCounter[0]}`];
+            }
+        }
+        switch (typeof value) {
+            case 'boolean': {
+                return boolSerialize(value);
+            }
+            case 'number': {
+                return numberSerialize(value);
+            }
+            case 'string': {
+                return stringSerialize(value);
+            }
+            case 'bigint': {
+                return [bigintSerialize(value)];
+            }
+            default: {
+                if (value === null) {
+                    return nullSerialize;
+                }
+                if (value === undefined) {
+                    return undefinedSerialize;
+                }
+                if (value instanceof Array) {
+                    return arraySerialize(value);
+                }
+                return objectSerialize(value);
+            }
+        }
+    };
+    const arraySerialize = compose(map(f))(arrayWrap);
+    return f;
+};
+const countRefsOp = djs => refs => {
+    switch (typeof djs) {
+        case 'boolean':
+        case 'number': {
+            return refs;
+        }
+        case 'string':
+        case 'bigint': {
+            return addRef(djs)(refs);
+        }
+        default: {
+            switch (djs) {
+                case null:
+                case undefined: {
+                    return refs;
+                }
+            }
+            if (djs instanceof Array) {
+                if (refs.has(djs))
+                    return addRef(djs)(refs);
+                return addRef(djs)(fold(countRefsOp)(refs)(djs));
+            }
+            if (refs.has(djs))
+                return addRef(djs)(refs);
+            return addRef(djs)(fold(countRefsOp)(refs)(map(entryValue)(entries(djs))));
+        }
+    }
+};
+const addRef = djs => refs => {
+    const refCounter = refs.get(djs);
+    if (refCounter === undefined) {
+        return refs.set(djs, [refs.size, 1, false]);
+    }
+    return refs.set(djs, [refCounter[0], refCounter[1] + 1, false]);
+};
+export const stringify = sort => djs => {
+    const refs = countRefs(djs);
+    const consts = getConstants(djs)({ refs, consts: [] }).consts;
+    const constSerialize = entry => {
+        const refCounter = refs.get(entry);
+        if (refCounter === undefined) {
+            throw 'unexpected behaviour';
+        }
+        return flat([['const c'], numberSerialize(refCounter[0]), [' = '], serializeWithConst(sort)(refs)(entry)(entry), ['\n']]);
+    };
+    const constStrings = flatMap(constSerialize)(consts);
+    const rootStrings = listConcat(['export default '])(serializeWithConst(sort)(refs)(djs)(djs));
+    return concat(listConcat(constStrings)(rootStrings));
+};
+export const stringifyAsTree = sort => compose(serializeWithoutConst(sort))(concat);
+export const countRefs = djs => {
+    return countRefsOp(djs)(new Map());
+};

package/djs/serializer/test.f.d.ts

@@ -1,5 +1,18 @@
 declare const _default: {
     stringify: ({
+        testPrimitives: () => void;
+        testArray: () => void;
+        testObj: () => void;
+        testSort?: never;
+        testIdentity?: never;
+    } | {
+        testSort: () => void;
+        testIdentity: () => void;
+        testPrimitives?: never;
+        testArray?: never;
+        testObj?: never;
+    })[];
+    stringifyAsTree: ({
         sort: () => void;
         identity: () => void;
         stringify?: never;

package/djs/serializer/test.f.js

@@ -1,21 +1,96 @@
-import * as json from "../../json/module.f.js";
+import { countRefs, stringify, stringifyAsTree } from "./module.f.js";
 import * as list from "../../types/object/module.f.js";
 const { sort } = list;
-import * as f from "../../types/function/module.f.js";
-const { identity } = f;
-import * as serializer from "./module.f.js";
+import { identity } from "../../types/function/module.f.js";
+import * as json from "../../json/module.f.js";
 export default {
     stringify: [
+        {
+            testPrimitives: () => {
+                const djs = [1, 2, 2, 2, true, false, undefined, null, 3n, "str"];
+                const refs = countRefs(djs);
+                if (refs.size !== 3) {
+                    throw refs.size;
+                }
+                const refsBigInt = stringifyAsTree(sort)(refs.get(3n));
+                if (refsBigInt !== '[0,1,false]') {
+                    throw refsBigInt;
+                }
+                const refsString = stringifyAsTree(sort)(refs.get("str"));
+                if (refsString !== '[1,1,false]') {
+                    throw refsString;
+                }
+                const refsRoot = stringifyAsTree(sort)(refs.get(djs));
+                if (refsRoot !== '[2,1,false]') {
+                    throw refsRoot;
+                }
+                if (refs.get(null) !== undefined) {
+                    throw refs.get(null);
+                }
+            },
+            testArray: () => {
+                const array = [null];
+                const djs = [array, array, array];
+                const refs = countRefs(djs);
+                if (refs.size !== 2) {
+                    throw refs.size;
+                }
+                const refsArray = stringifyAsTree(sort)(refs.get(array));
+                if (refsArray !== '[0,3,false]') {
+                    throw refsArray;
+                }
+                const refsRoot = stringifyAsTree(sort)(refs.get(djs));
+                if (refsRoot !== '[1,1,false]') {
+                    throw refsRoot;
+                }
+            },
+            testObj: () => {
+                const obj = { "a": 1, "b": 2 };
+                const djs = [obj, obj, 1];
+                const refs = countRefs(djs);
+                if (refs.size !== 2) {
+                    throw refs.size;
+                }
+                const refsObj = stringifyAsTree(sort)(refs.get(obj));
+                if (refsObj !== '[0,2,false]') {
+                    throw refsObj;
+                }
+                const refsRoot = stringifyAsTree(sort)(refs.get(djs));
+                if (refsRoot !== '[1,1,false]') {
+                    throw refsRoot;
+                }
+            },
+        },
+        {
+            testSort: () => {
+                const obj = { "a": 1, "c": 2n, "b": [undefined, null, true, false] };
+                const djs = [obj, obj, 1];
+                const res = stringify(sort)(djs);
+                if (res !== 'const c2 = {"a":1,"b":[undefined,null,true,false],"c":2n}\nexport default [c2,c2,1]') {
+                    throw res;
+                }
+            },
+            testIdentity: () => {
+                const obj = { "a": 1, "c": 2n, "b": [undefined, null, true, false] };
+                const djs = [obj, obj, 1];
+                const res = stringify(identity)(djs);
+                if (res !== 'const c2 = {"a":1,"c":2n,"b":[undefined,null,true,false]}\nexport default [c2,c2,1]') {
+                    throw res;
+                }
+            },
+        }
+    ],
+    stringifyAsTree: [
         {
             sort: () => {
                 const r = json.setProperty("Hello")(['a'])({});
-                const x = serializer.stringify(sort)(r);
+                const x = stringifyAsTree(sort)(r);
                 if (x !== '{"a":"Hello"}') {
                     throw x;
                 }
             },
             identity: () => {
-                const x = serializer.stringify(identity)(json.setProperty("Hello")(['a'])({}));
+                const x = stringifyAsTree(identity)(json.setProperty("Hello")(['a'])({}));
                 if (x !== '{"a":"Hello"}') {
                     throw x;
                 }
@@ -23,13 +98,13 @@ export default {
         },
         {
             sort: () => {
-                const x = serializer.stringify(sort)(json.setProperty("Hello")(['a'])({ c: [], b: 12 }));
+                const x = stringifyAsTree(sort)(json.setProperty("Hello")(['a'])({ c: [], b: 12 }));
                 if (x !== '{"a":"Hello","b":12,"c":[]}') {
                     throw x;
                 }
             },
             identity: () => {
-                const x = serializer.stringify(identity)(json.setProperty("Hello")(['a'])({ c: [], b: 12 }));
+                const x = stringifyAsTree(identity)(json.setProperty("Hello")(['a'])({ c: [], b: 12 }));
                 if (x !== '{"c":[],"b":12,"a":"Hello"}') {
                     throw x;
                 }
@@ -39,7 +114,7 @@ export default {
             sort: () => {
                 const _0 = { a: { y: [24] }, c: [], b: 12 };
                 const _1 = json.setProperty("Hello")(['a', 'x'])(_0);
-                const _2 = serializer.stringify(sort)(_1);
+                const _2 = stringifyAsTree(sort)(_1);
                 if (_2 !== '{"a":{"x":"Hello","y":[24]},"b":12,"c":[]}') {
                     throw _2;
                 }
@@ -47,7 +122,7 @@ export default {
             identity: () => {
                 const _0 = { a: { y: [24] }, c: [], b: 12 };
                 const _1 = json.setProperty("Hello")(['a', 'x'])(_0);
-                const _2 = serializer.stringify(identity)(_1);
+                const _2 = stringifyAsTree(identity)(_1);
                 if (_2 !== '{"a":{"y":[24],"x":"Hello"},"c":[],"b":12}') {
                     throw _2;
                 }
@@ -56,7 +131,7 @@ export default {
         {
             stringify: () => {
                 const bi = 1234567890n;
-                const result = serializer.stringify(sort)(bi);
+                const result = stringifyAsTree(sort)(bi);
                 if (result !== '1234567890n') {
                     throw result;
                 }
@@ -65,7 +140,7 @@ export default {
         {
             stringify: () => {
                 const arr = [0n, 1, 2n];
-                const result = serializer.stringify(sort)(arr);
+                const result = stringifyAsTree(sort)(arr);
                 if (result !== '[0n,1,2n]') {
                     throw result;
                 }
@@ -74,7 +149,7 @@ export default {
         {
             stringify: () => {
                 const obj = { "a": 0n, "b": 1, "c": 2n };
-                const result = serializer.stringify(sort)(obj);
+                const result = stringifyAsTree(sort)(obj);
                 if (result !== '{"a":0n,"b":1,"c":2n}') {
                     throw result;
                 }

package/djs/test/input.f.js

@@ -1,4 +1,4 @@
 import c from "./m.f.js";
 const a = 1;
 const b = 2;
-export default [a, b, c];
+export default [a, a, b, c, c];

package/djs/tokenizer/test.f.js

@@ -6,7 +6,7 @@ import * as o from "../../types/object/module.f.js";
 const { sort } = o;
 import * as encoding from "../../text/utf16/module.f.js";
 const tokenizeString = s => toArray(tokenizer.tokenize(encoding.stringToList(s)));
-const stringify = serializer.stringify(sort);
+const stringify = serializer.stringifyAsTree(sort);
 export default {
     djs: [
         () => {

package/djs/transpiler/test.f.js

@@ -1,7 +1,7 @@
 import { sort } from "../../types/object/module.f.js";
 import { setReplace } from "../../types/ordered_map/module.f.js";
 import { transpile } from "./module.f.js";
-import { stringify } from "../serializer/module.f.js";
+import { stringifyAsTree } from "../serializer/module.f.js";
 import { createVirtualIo } from "../../io/virtual/module.f.js";
 const virtualFs = map => {
     return createVirtualIo(map).fs;
@@ -14,7 +14,7 @@ export default {
         if (result[0] === 'error') {
             throw result[1];
         }
-        const s = stringify(sort)(result[1]);
+        const s = stringifyAsTree(sort)(result[1]);
         if (s !== '1') {
             throw s;
         }
@@ -27,7 +27,7 @@ export default {
         if (result[0] === 'error') {
             throw result[1];
         }
-        const s = stringify(sort)(result[1]);
+        const s = stringifyAsTree(sort)(result[1]);
         if (s !== '2') {
             throw s;
         }
@@ -42,7 +42,7 @@ export default {
         if (result[0] === 'error') {
             throw result[1];
         }
-        const s = stringify(sort)(result[1]);
+        const s = stringifyAsTree(sort)(result[1]);
         if (s !== '[[0,2],[1,2],[0,2]]') {
             throw s;
         }

package/js/tokenizer/test.f.js

@@ -6,7 +6,7 @@ import * as o from "../../types/object/module.f.js";
 const { sort } = o;
 import * as encoding from "../../text/utf16/module.f.js";
 const tokenizeString = s => toArray(tokenizer.tokenize(encoding.stringToList(s)));
-const stringify = serializer.stringify(sort);
+const stringify = serializer.stringifyAsTree(sort);
 export default {
     djs: [
         () => {

package/json/tokenizer/test.f.js

@@ -6,7 +6,7 @@ import * as o from "../../types/object/module.f.js";
 const { sort } = o;
 import * as encoding from "../../text/utf16/module.f.js";
 const tokenizeString = s => toArray(tokenizer.tokenize(encoding.stringToList(s)));
-const stringify = serializer.stringify(sort);
+const stringify = serializer.stringifyAsTree(sort);
 export default {
     json: [
         () => {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "functionalscript",
-  "version": "0.6.6",
+  "version": "0.6.8",
   "type": "module",
   "files": [
     "**/*.js",
@@ -46,7 +46,7 @@
   },
   "homepage": "https://github.com/functionalscript/functionalscript#readme",
   "devDependencies": {
-    "@types/node": "^22.14.1",
+    "@types/node": "^22.15.17",
     "typescript": "^5.8.3"
   }
 }