@psync/patch-package 1.0.0 → 1.0.2

package/dist/strictMode.js

@@ -0,0 +1,299 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createStrictBaseline = createStrictBaseline;
+exports.listTarGzEntries = listTarGzEntries;
+exports.pruneToBaseline = pruneToBaseline;
+const zlib_1 = require("zlib");
+const https_1 = require("https");
+const http_1 = require("http");
+const url_1 = require("url");
+const fs_extra_1 = require("fs-extra");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const path_2 = require("./path");
+/**
+ * Build a baseline provider for a given package resolution.
+ *
+ * `resolution` is whatever `getPackageResolution` returned — typically:
+ *  - "https://registry.yarnpkg.com/foo/-/foo-1.2.3.tgz#sha512-..."  (yarn / bun.lockb)
+ *  - "https://registry.npmjs.org/foo/-/foo-1.2.3.tgz"               (npm via lockfile)
+ *  - "1.2.3"                                                        (version-only, e.g. bun.lock text)
+ *  - "npm:bar@1.2.3"                                                (alias)
+ *  - "file:./path"                                                  (local file)
+ *  - "git+https://..."                                              (git url)
+ */
+function createStrictBaseline({ packageName, resolution, appPath, }) {
+    return {
+        async getOriginalTarballFiles() {
+            // CASE 1: file:./path -> walk local directory and return relative paths
+            if (resolution.startsWith("file:")) {
+                const localPath = (0, path_2.resolve)(appPath, resolution.slice("file:".length));
+                if (!(0, fs_1.existsSync)(localPath))
+                    return null;
+                try {
+                    if ((0, fs_1.statSync)(localPath).isDirectory()) {
+                        return walkLocalDirectory(localPath, localPath);
+                    }
+                }
+                catch {
+                    return null;
+                }
+                return null;
+            }
+            // CASE 2: looks like a .tgz URL -> download, gunzip, parse tar
+            if (resolution.endsWith(".tgz") ||
+                resolution.endsWith(".tar.gz") ||
+                /\bhttps?:\/\/.*\.(tgz|tar\.gz)(\?|#|$)/i.test(resolution)) {
+                const url = resolution.split("#")[0];
+                try {
+                    const tarball = await fetchBuffer(url);
+                    return new Set(listTarGzEntries(tarball));
+                }
+                catch {
+                    return null;
+                }
+            }
+            // CASE 3: looks like a git URL
+            if (resolution.startsWith("git+") || resolution.endsWith(".git")) {
+                return null;
+            }
+            // CASE 4: plain version like "1.2.3", possibly with an `npm:` alias
+            // -> resolve via the npm registry metadata endpoint
+            const aliasResolved = parseNpmAlias(resolution);
+            const name = aliasResolved.name ?? packageName;
+            const version = aliasResolved.version ?? resolution;
+            if (!version.match(/^v?\d/))
+                return null;
+            try {
+                const tarballUrl = await fetchTarballUrlFromRegistry(name, version);
+                if (!tarballUrl)
+                    return null;
+                const tarball = await fetchBuffer(tarballUrl);
+                return new Set(listTarGzEntries(tarball));
+            }
+            catch {
+                return null;
+            }
+        },
+    };
+}
+function parseNpmAlias(resolution) {
+    if (resolution.startsWith("npm:")) {
+        const rest = resolution.slice("npm:".length);
+        const atIdx = rest.lastIndexOf("@");
+        if (atIdx > 0) {
+            return { name: rest.slice(0, atIdx), version: rest.slice(atIdx + 1) };
+        }
+        return { name: rest };
+    }
+    if (/^v?\d/.test(resolution)) {
+        return { version: resolution };
+    }
+    return {};
+}
+/** Walks a local directory recursively and returns forward-slash relative paths. */
+function walkLocalDirectory(root, current) {
+    const out = new Set();
+    for (const entry of (0, fs_1.readdirSync)(current, { withFileTypes: true })) {
+        const abs = (0, path_1.join)(current, entry.name);
+        const rel = abs.slice(root.length + 1).replace(/\\/g, "/");
+        if (entry.isDirectory()) {
+            out.add(rel + "/");
+            for (const sub of walkLocalDirectory(root, abs)) {
+                out.add(sub);
+            }
+        }
+        else if (entry.isFile()) {
+            out.add(rel);
+        }
+    }
+    return out;
+}
+/**
+ * Fetches the `dist.tarball` URL for a package version from the npm registry
+ * metadata endpoint. Returns null if the package/version can't be found.
+ */
+function fetchTarballUrlFromRegistry(name, version) {
+    const encodedName = name.startsWith("@")
+        ? "@" + encodeURIComponent(name.slice(1))
+        : encodeURIComponent(name);
+    const url = `https://registry.npmjs.org/${encodedName}/${encodeURIComponent(version)}`;
+    return new Promise((resolveP) => {
+        fetchJson(url)
+            .then((json) => {
+            const tarball = json?.dist?.tarball;
+            resolveP(typeof tarball === "string" ? tarball : null);
+        })
+            .catch(() => resolveP(null));
+    });
+}
+function fetchBuffer(url) {
+    return new Promise((resolveP, rejectP) => {
+        let parsed;
+        try {
+            parsed = new url_1.URL(url);
+        }
+        catch {
+            rejectP(new Error(`Invalid URL: ${url}`));
+            return;
+        }
+        const lib = parsed.protocol === "https:" ? https_1.request : http_1.request;
+        const opts = {
+            method: "GET",
+            hostname: parsed.hostname,
+            port: parsed.port || (parsed.protocol === "https:" ? 443 : 80),
+            path: parsed.pathname + parsed.search,
+            headers: {
+                "User-Agent": "patch-package",
+                Accept: "application/octet-stream, */*",
+            },
+        };
+        const req = lib(opts, (res) => {
+            if (res.statusCode &&
+                res.statusCode >= 300 &&
+                res.statusCode < 400 &&
+                res.headers.location) {
+                fetchBuffer(res.headers.location).then(resolveP, rejectP);
+                res.resume();
+                return;
+            }
+            if (res.statusCode !== 200) {
+                rejectP(new Error(`HTTP ${res.statusCode} for ${url}`));
+                res.resume();
+                return;
+            }
+            const chunks = [];
+            res.on("data", (c) => chunks.push(c));
+            res.on("end", () => resolveP(Buffer.concat(chunks)));
+            res.on("error", rejectP);
+        });
+        req.on("error", rejectP);
+        req.setTimeout(15000, () => req.destroy(new Error("Tarball download timed out")));
+        req.end();
+    });
+}
+function fetchJson(url) {
+    return fetchBuffer(url).then((buf) => JSON.parse(buf.toString("utf8")));
+}
+/**
+ * Lists the file paths inside a gzipped tarball buffer.
+ *
+ * Tar format: 512-byte header + <size> bytes of file content, padded to
+ * the next 512-byte boundary. We don't extract file contents — only the
+ * `name` field of each header is read, which is enough to compute the
+ * baseline file set.
+ */
+function listTarGzEntries(tarGz) {
+    const tar = (0, zlib_1.gunzipSync)(tarGz);
+    const out = [];
+    const HEADER_SIZE = 512;
+    const BLOCK_SIZE = 512;
+    // Common prefix (e.g. "package/") that npm and yarn add to every entry —
+    // stripped so paths match the user's node_modules layout.
+    let leadingPrefix = null;
+    let offset = 0;
+    while (offset + HEADER_SIZE <= tar.length) {
+        if (tar[offset] === 0 &&
+            tar.subarray(offset, offset + HEADER_SIZE).every((b) => b === 0)) {
+            break;
+        }
+        const name = readCString(tar, offset, 100);
+        const sizeOctal = readCString(tar, offset + 124, 12);
+        const typeFlag = String.fromCharCode(tar[offset + 156]);
+        const entrySize = parseOctal(sizeOctal) || 0;
+        const paddedSize = Math.ceil(entrySize / BLOCK_SIZE) * BLOCK_SIZE;
+        // PAX extended header / long-name redirect — skip its blocks only.
+        if (typeFlag === "x" || typeFlag === "g" || typeFlag === "L") {
+            offset += HEADER_SIZE + paddedSize;
+            continue;
+        }
+        if (leadingPrefix === null && name) {
+            const firstSlash = name.indexOf("/");
+            leadingPrefix = firstSlash >= 0 ? name.slice(0, firstSlash + 1) : "";
+        }
+        if (leadingPrefix && name.startsWith(leadingPrefix)) {
+            const cleaned = name.slice(leadingPrefix.length);
+            if (cleaned && !cleaned.endsWith("/")) {
+                out.push(cleaned);
+            }
+        }
+        else if (name && !name.endsWith("/")) {
+            out.push(name);
+        }
+        offset += HEADER_SIZE + paddedSize;
+    }
+    return out;
+}
+/** Read a NUL-terminated UTF-8 string of `maxLen` bytes at `offset`. */
+function readCString(buf, offset, maxLen) {
+    const slice = buf.subarray(offset, offset + maxLen);
+    const nulIdx = slice.indexOf(0);
+    return slice.subarray(0, nulIdx < 0 ? maxLen : nulIdx).toString("utf8");
+}
+/** Parse an octal string (e.g. "000142") into a number. */
+function parseOctal(s) {
+    const trimmed = s.replace(/\0/g, "").trim();
+    if (!trimmed)
+        return 0;
+    if (/^[0-7]+$/.test(trimmed)) {
+        return parseInt(trimmed, 8);
+    }
+    return 0;
+}
+/**
+ * Removes files from `treeRoot` whose relative paths (forward slashes, sans
+ * leading `./`) are NOT in `baseline`. Any directory that becomes empty as
+ * a side effect is also removed, so git doesn't include empty-dir noise in
+ * the resulting patch.
+ */
+function pruneToBaseline(treeRoot, baseline) {
+    let pruned = 0;
+    walk(treeRoot, (absPath, relativePath) => {
+        if (!(0, fs_1.statSync)(absPath).isFile())
+            return;
+        const normalized = relativePath.replace(/\\/g, "/");
+        if (!baseline.has(normalized)) {
+            (0, fs_extra_1.removeSync)(absPath);
+            pruned++;
+        }
+    });
+    pruneEmptyDirs(treeRoot);
+    return { pruned };
+}
+function walk(root, visit) {
+    function recurse(absPath, relPath) {
+        const entries = (0, fs_1.readdirSync)(absPath, { withFileTypes: true });
+        for (const entry of entries) {
+            const childAbs = (0, path_1.join)(absPath, entry.name);
+            const childRel = relPath ? `${relPath}/${entry.name}` : entry.name;
+            if (entry.isDirectory()) {
+                recurse(childAbs, childRel);
+            }
+            else {
+                visit(childAbs, childRel);
+            }
+        }
+    }
+    recurse(root, "");
+}
+function pruneEmptyDirs(root) {
+    function recurse(dir) {
+        const entries = (0, fs_1.readdirSync)(dir, { withFileTypes: true });
+        for (const entry of entries) {
+            if (!entry.isDirectory())
+                continue;
+            const child = (0, path_1.join)(dir, entry.name);
+            recurse(child);
+        }
+        if (dir !== root && (0, fs_1.readdirSync)(dir).length === 0) {
+            try {
+                (0, fs_1.rmdirSync)(dir);
+            }
+            catch {
+                // ignore
+            }
+        }
+    }
+    recurse(root);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"strictMode.js","sourceRoot":"","sources":["../src/strictMode.ts"],"names":[],"mappings":"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","sourcesContent":["import { gunzipSync } from \"zlib\"\nimport { request as httpsRequest, RequestOptions } from \"https\"\nimport {\n  request as httpRequest,\n  RequestOptions as HttpRequestOptions,\n} from \"http\"\nimport { URL } from \"url\"\nimport { removeSync } from \"fs-extra\"\nimport { existsSync, statSync, readdirSync, rmdirSync } from \"fs\"\nimport { join } from \"path\"\nimport { resolve as resolvePath } from \"./path\"\n\n/**\n * Strict-mode support for `patch-package`.\n *\n * In strict mode, after the user's edited copy of the package has been\n * staged in the temp git repo, any file whose path was NOT part of the\n * original published package (the tarball at the resolved URL) is removed\n * from the tree before computing the diff. This prevents the\n * \"--- /dev/null\" (\"new file\") entries that appear when a package manager\n * install in the temp directory produces a slightly different file layout\n * than the user's `node_modules` copy.\n *\n * Returns `null` when the baseline cannot be determined — callers warn the\n * user and proceed without strict filtering.\n */\nexport type StrictBaselineProvider = {\n  /** Set of relative file paths (forward slashes) that the original\n   * published package contained, or `null` if not determinable. */\n  getOriginalTarballFiles(): Promise<Set<string> | null>\n}\n\n/**\n * Build a baseline provider for a given package resolution.\n *\n * `resolution` is whatever `getPackageResolution` returned — typically:\n *  - \"https://registry.yarnpkg.com/foo/-/foo-1.2.3.tgz#sha512-...\"  (yarn / bun.lockb)\n *  - \"https://registry.npmjs.org/foo/-/foo-1.2.3.tgz\"               (npm via lockfile)\n *  - \"1.2.3\"                                                        (version-only, e.g. bun.lock text)\n *  - \"npm:bar@1.2.3\"                                                (alias)\n *  - \"file:./path\"                                                  (local file)\n *  - \"git+https://...\"                                              (git url)\n */\nexport function createStrictBaseline({\n  packageName,\n  resolution,\n  appPath,\n}: {\n  packageName: string\n  resolution: string\n  appPath: string\n}): StrictBaselineProvider {\n  return {\n    async getOriginalTarballFiles() {\n      // CASE 1: file:./path -> walk local directory and return relative paths\n      if (resolution.startsWith(\"file:\")) {\n        const localPath = resolvePath(appPath, resolution.slice(\"file:\".length))\n        if (!existsSync(localPath)) return null\n        try {\n          if (statSync(localPath).isDirectory()) {\n            return walkLocalDirectory(localPath, localPath)\n          }\n        } catch {\n          return null\n        }\n        return null\n      }\n\n      // CASE 2: looks like a .tgz URL -> download, gunzip, parse tar\n      if (\n        resolution.endsWith(\".tgz\") ||\n        resolution.endsWith(\".tar.gz\") ||\n        /\\bhttps?:\\/\\/.*\\.(tgz|tar\\.gz)(\\?|#|$)/i.test(resolution)\n      ) {\n        const url = resolution.split(\"#\")[0]\n        try {\n          const tarball = await fetchBuffer(url)\n          return new Set(listTarGzEntries(tarball))\n        } catch {\n          return null\n        }\n      }\n\n      // CASE 3: looks like a git URL\n      if (resolution.startsWith(\"git+\") || resolution.endsWith(\".git\")) {\n        return null\n      }\n\n      // CASE 4: plain version like \"1.2.3\", possibly with an `npm:` alias\n      // -> resolve via the npm registry metadata endpoint\n      const aliasResolved = parseNpmAlias(resolution)\n      const name = aliasResolved.name ?? packageName\n      const version = aliasResolved.version ?? resolution\n      if (!version.match(/^v?\\d/)) return null\n      try {\n        const tarballUrl = await fetchTarballUrlFromRegistry(name, version)\n        if (!tarballUrl) return null\n        const tarball = await fetchBuffer(tarballUrl)\n        return new Set(listTarGzEntries(tarball))\n      } catch {\n        return null\n      }\n    },\n  }\n}\n\nfunction parseNpmAlias(resolution: string): {\n  name?: string\n  version?: string\n} {\n  if (resolution.startsWith(\"npm:\")) {\n    const rest = resolution.slice(\"npm:\".length)\n    const atIdx = rest.lastIndexOf(\"@\")\n    if (atIdx > 0) {\n      return { name: rest.slice(0, atIdx), version: rest.slice(atIdx + 1) }\n    }\n    return { name: rest }\n  }\n  if (/^v?\\d/.test(resolution)) {\n    return { version: resolution }\n  }\n  return {}\n}\n\n/** Walks a local directory recursively and returns forward-slash relative paths. */\nfunction walkLocalDirectory(root: string, current: string): Set<string> {\n  const out = new Set<string>()\n  for (const entry of readdirSync(current, { withFileTypes: true })) {\n    const abs = join(current, entry.name)\n    const rel = abs.slice(root.length + 1).replace(/\\\\/g, \"/\")\n    if (entry.isDirectory()) {\n      out.add(rel + \"/\")\n      for (const sub of walkLocalDirectory(root, abs)) {\n        out.add(sub)\n      }\n    } else if (entry.isFile()) {\n      out.add(rel)\n    }\n  }\n  return out\n}\n\n/**\n * Fetches the `dist.tarball` URL for a package version from the npm registry\n * metadata endpoint. Returns null if the package/version can't be found.\n */\nfunction fetchTarballUrlFromRegistry(\n  name: string,\n  version: string,\n): Promise<string | null> {\n  const encodedName = name.startsWith(\"@\")\n    ? \"@\" + encodeURIComponent(name.slice(1))\n    : encodeURIComponent(name)\n  const url = `https://registry.npmjs.org/${encodedName}/${encodeURIComponent(version)}`\n  return new Promise((resolveP) => {\n    fetchJson(url)\n      .then((json) => {\n        const tarball = json?.dist?.tarball\n        resolveP(typeof tarball === \"string\" ? tarball : null)\n      })\n      .catch(() => resolveP(null))\n  })\n}\n\nfunction fetchBuffer(url: string): Promise<Buffer> {\n  return new Promise((resolveP, rejectP) => {\n    let parsed: URL\n    try {\n      parsed = new URL(url)\n    } catch {\n      rejectP(new Error(`Invalid URL: ${url}`))\n      return\n    }\n    const lib = parsed.protocol === \"https:\" ? httpsRequest : httpRequest\n    const opts = {\n      method: \"GET\",\n      hostname: parsed.hostname,\n      port: parsed.port || (parsed.protocol === \"https:\" ? 443 : 80),\n      path: parsed.pathname + parsed.search,\n      headers: {\n        \"User-Agent\": \"patch-package\",\n        Accept: \"application/octet-stream, */*\",\n      },\n    } as RequestOptions & HttpRequestOptions\n    const req = lib(opts, (res) => {\n      if (\n        res.statusCode &&\n        res.statusCode >= 300 &&\n        res.statusCode < 400 &&\n        res.headers.location\n      ) {\n        fetchBuffer(res.headers.location).then(resolveP, rejectP)\n        res.resume()\n        return\n      }\n      if (res.statusCode !== 200) {\n        rejectP(new Error(`HTTP ${res.statusCode} for ${url}`))\n        res.resume()\n        return\n      }\n      const chunks: Buffer[] = []\n      res.on(\"data\", (c: Buffer) => chunks.push(c))\n      res.on(\"end\", () => resolveP(Buffer.concat(chunks)))\n      res.on(\"error\", rejectP)\n    })\n    req.on(\"error\", rejectP)\n    req.setTimeout(15000, () =>\n      req.destroy(new Error(\"Tarball download timed out\")),\n    )\n    req.end()\n  })\n}\n\nfunction fetchJson(url: string): Promise<any> {\n  return fetchBuffer(url).then((buf) => JSON.parse(buf.toString(\"utf8\")))\n}\n\n/**\n * Lists the file paths inside a gzipped tarball buffer.\n *\n * Tar format: 512-byte header + <size> bytes of file content, padded to\n * the next 512-byte boundary. We don't extract file contents — only the\n * `name` field of each header is read, which is enough to compute the\n * baseline file set.\n */\nexport function listTarGzEntries(tarGz: Buffer): string[] {\n  const tar = gunzipSync(tarGz)\n  const out: string[] = []\n  const HEADER_SIZE = 512\n  const BLOCK_SIZE = 512\n\n  // Common prefix (e.g. \"package/\") that npm and yarn add to every entry —\n  // stripped so paths match the user's node_modules layout.\n  let leadingPrefix: string | null = null\n\n  let offset = 0\n  while (offset + HEADER_SIZE <= tar.length) {\n    if (\n      tar[offset] === 0 &&\n      tar.subarray(offset, offset + HEADER_SIZE).every((b) => b === 0)\n    ) {\n      break\n    }\n\n    const name = readCString(tar, offset, 100)\n    const sizeOctal = readCString(tar, offset + 124, 12)\n    const typeFlag = String.fromCharCode(tar[offset + 156])\n\n    const entrySize = parseOctal(sizeOctal) || 0\n    const paddedSize = Math.ceil(entrySize / BLOCK_SIZE) * BLOCK_SIZE\n\n    // PAX extended header / long-name redirect — skip its blocks only.\n    if (typeFlag === \"x\" || typeFlag === \"g\" || typeFlag === \"L\") {\n      offset += HEADER_SIZE + paddedSize\n      continue\n    }\n\n    if (leadingPrefix === null && name) {\n      const firstSlash = name.indexOf(\"/\")\n      leadingPrefix = firstSlash >= 0 ? name.slice(0, firstSlash + 1) : \"\"\n    }\n\n    if (leadingPrefix && name.startsWith(leadingPrefix)) {\n      const cleaned = name.slice(leadingPrefix.length)\n      if (cleaned && !cleaned.endsWith(\"/\")) {\n        out.push(cleaned)\n      }\n    } else if (name && !name.endsWith(\"/\")) {\n      out.push(name)\n    }\n\n    offset += HEADER_SIZE + paddedSize\n  }\n\n  return out\n}\n\n/** Read a NUL-terminated UTF-8 string of `maxLen` bytes at `offset`. */\nfunction readCString(buf: Buffer, offset: number, maxLen: number): string {\n  const slice = buf.subarray(offset, offset + maxLen)\n  const nulIdx = slice.indexOf(0)\n  return slice.subarray(0, nulIdx < 0 ? maxLen : nulIdx).toString(\"utf8\")\n}\n\n/** Parse an octal string (e.g. \"000142\") into a number. */\nfunction parseOctal(s: string): number {\n  const trimmed = s.replace(/\\0/g, \"\").trim()\n  if (!trimmed) return 0\n  if (/^[0-7]+$/.test(trimmed)) {\n    return parseInt(trimmed, 8)\n  }\n  return 0\n}\n\n/**\n * Removes files from `treeRoot` whose relative paths (forward slashes, sans\n * leading `./`) are NOT in `baseline`. Any directory that becomes empty as\n * a side effect is also removed, so git doesn't include empty-dir noise in\n * the resulting patch.\n */\nexport function pruneToBaseline(\n  treeRoot: string,\n  baseline: Set<string>,\n): { pruned: number } {\n  let pruned = 0\n  walk(treeRoot, (absPath, relativePath) => {\n    if (!statSync(absPath).isFile()) return\n    const normalized = relativePath.replace(/\\\\/g, \"/\")\n    if (!baseline.has(normalized)) {\n      removeSync(absPath)\n      pruned++\n    }\n  })\n  pruneEmptyDirs(treeRoot)\n  return { pruned }\n}\n\nfunction walk(\n  root: string,\n  visit: (absPath: string, relPath: string) => void,\n): void {\n  function recurse(absPath: string, relPath: string): void {\n    const entries = readdirSync(absPath, { withFileTypes: true })\n    for (const entry of entries) {\n      const childAbs = join(absPath, entry.name)\n      const childRel = relPath ? `${relPath}/${entry.name}` : entry.name\n      if (entry.isDirectory()) {\n        recurse(childAbs, childRel)\n      } else {\n        visit(childAbs, childRel)\n      }\n    }\n  }\n  recurse(root, \"\")\n}\n\nfunction pruneEmptyDirs(root: string): void {\n  function recurse(dir: string): void {\n    const entries = readdirSync(dir, { withFileTypes: true })\n    for (const entry of entries) {\n      if (!entry.isDirectory()) continue\n      const child = join(dir, entry.name)\n      recurse(child)\n    }\n    if (dir !== root && readdirSync(dir).length === 0) {\n      try {\n        rmdirSync(dir)\n      } catch {\n        // ignore\n      }\n    }\n  }\n  recurse(root)\n}\n"]}

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@psync/patch-package",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "description": "Fix broken node modules with no fuss",
   "main": "dist/index.js",
   "repository": "github:New-Elysium/patch-package",
-  "author": "David Sheldrick",
-  "license": "MIT",
+  "author": "Srikanth Gopalakrishnan",
+  "license": "Apache-2.0",
   "engines": {
-    "node": ">=14",
-    "npm": ">5",
+    "node": ">=24",
+    "npm": ">10",
     "bun": ">=1.3.14"
   },
   "bin": {
@@ -69,7 +69,7 @@
     "ts-jest": "^29.4.0",
     "ts-node": "^10.9.0",
     "tslib": "^2.8.0",
-    "typescript": "^6.0.0"
+    "typescript": "^6.0.3"
   },
   "dependencies": {
     "@yarnpkg/lockfile": "^1.1.0",