From bdc0b253ef9eed9930ef91f8e628d2df77945dac Mon Sep 17 00:00:00 2001 From: Vaibhav Lalwani Date: Fri, 28 Aug 2026 10:54:07 +0000 Subject: [PATCH 1/2] Add submission package for microsoft/TypeScript issue 55091 Prepared fix, regression test, PR body and verification record for the enum non-finite constant emit bug. Not yet submitted upstream. --- contrib/typescript-55091/PR_BODY.md | 74 ++++++ contrib/typescript-55091/README.md | 82 +++++++ contrib/typescript-55091/fix.patch | 355 ++++++++++++++++++++++++++++ 3 files changed, 511 insertions(+) create mode 100644 contrib/typescript-55091/PR_BODY.md create mode 100644 contrib/typescript-55091/README.md create mode 100644 contrib/typescript-55091/fix.patch diff --git a/contrib/typescript-55091/PR_BODY.md b/contrib/typescript-55091/PR_BODY.md new file mode 100644 index 0000000..1d7d492 --- /dev/null +++ b/contrib/typescript-55091/PR_BODY.md @@ -0,0 +1,74 @@ +Fixes #55091 + +### Problem + +Enum members whose initializers evaluate to `Infinity`, `-Infinity`, or `NaN` are +emitted as the global identifiers of those names. Identifiers resolve in the scope of +the *emitted* code rather than at the enum declaration, so a local binding that shadows +`Infinity` or `NaN` silently changes the member's value at runtime: + +```ts +{ + let Infinity = 3; + enum A { + X = 1 / 0 + } + console.log(A.X); // 3, expected Infinity +} +``` + +emits + +```js +A[A["X"] = Infinity] = "X"; +``` + +This compiles with no diagnostic. `const enum` members are protected here by TS2477 and +TS2478, but plain enums are not, so the value is wrong with nothing to indicate it. + +### Change + +`constantExpression` now emits `1 / 0`, `-1 / 0`, and `0 / 0` for these three values. +They evaluate to exactly the same numbers and cannot be shadowed, which is the same +reasoning behind emitting `void 0` rather than `undefined`. + +The `-Infinity` case prints as `-1 / 0` rather than `-(1 / 0)`; unary minus binds tighter +than division, so no parentheses are needed. + +### Testing + +I added `tests/cases/conformance/enums/enumComputedNonFiniteShadowed.ts`, covering all +three values both under a shadowing binding and without one. + +By hand, I built the compiler from this branch and ran the case above through it. Before +the change the emitted program printed `Pos: 3 Neg: -3 Nan: 7`; after it, it printed +`Pos: Infinity Neg: -Infinity Nan: NaN`. + +Five existing emit baselines change, in each case only `Infinity`/`NaN` becoming the +division form: `enumConstantMembers`, `enumNaNValues`, `enumAutoIncrementValue`, +`fakeInfinity2`, and `fakeInfinity3`. No `.types`, `.symbols`, or `.d.ts` baseline +changes, since checking is untouched. `enumShadowedInfinityNaN` is unaffected, as that +test references the identifiers directly rather than computing a constant. + +I ran `go test ./...` under `tsc/`: 62 packages pass. `internal/astnav` fails in my +environment because it loads `node_modules/typescript/lib/typescript.js`, which I had not +installed; I confirmed it fails identically with this change stashed. I did not run the +`npx hereby` wrappers for that reason, but `gofmt -l` and `go vet ./internal/transformers/...` +are both clean. + +### Key points + +The tradeoff is emit readability: `E[E["a"] = 1 / 0] = "a"` reads less clearly than +`= Infinity` for the common, non-shadowed case. I chose the unconditional form because it +is correct without needing to resolve `Infinity`/`NaN` at the emit site. If you would +rather keep the identifier when it is demonstrably not shadowed, I am happy to rework it +that way. + +This does not address declaration emit, which has the same underlying problem: the +committed `fakeInfinity3.d.ts` baseline still carries TS1066 and TS2749 errors. That +looked like a separate change, so I left it out rather than widen this one. + +### AI assistance + +This patch was written with AI assistance (Claude Code). I have read and understand the +change and will be responding to review feedback myself. diff --git a/contrib/typescript-55091/README.md b/contrib/typescript-55091/README.md new file mode 100644 index 0000000..b42a95b --- /dev/null +++ b/contrib/typescript-55091/README.md @@ -0,0 +1,82 @@ +# microsoft/TypeScript #55091 - submission package + +Status: **prepared, not submitted.** Submission is a manual step for the repository +owner, for the reasons in "Why you submit this" below. + +## Record + +| Field | Value | +|---|---| +| Organization | Microsoft | +| Repository | microsoft/TypeScript | +| Issue | [#55091](https://github.com/microsoft/TypeScript/issues/55091) - `Help Wanted`, unassigned, milestone `Dormant` | +| Prior art | [#55107](https://github.com/microsoft/TypeScript/pull/55107) by Andarist, closed 2026-03-24 in the post-6.0 mass closure, not rejected on merit | +| Base commit | `9b323de` era clone of `main` (Go compiler; verify against latest before submitting) | +| Files changed | 1 source, 1 new test, 8 baselines | +| Diff | +43 / -24 in source; baselines mechanical | +| PR body | `PR_BODY.md` | +| Patch | `fix.patch` | + +## The bug + +`tsc/internal/transformers/tstransforms/utilities.go`, `constantExpression()` emitted +bare `Infinity` / `-Infinity` / `NaN` identifiers for enum members whose initializers +fold to those values. Identifiers resolve in the emitted code's scope, so shadowing +changes the value silently. Reproduced on published TypeScript 7.0.2: + +``` +$ cat repro.ts +{ + let Infinity = 3; + enum A { X = 1 / 0 } + console.log(A.X); +} +$ tsc --target es2020 repro.ts && node repro.js +3 # expected: Infinity +``` + +No diagnostic is issued. `const enum` is guarded by TS2477/TS2478; plain `enum` is not. + +## Verification performed + +- `go build ./...` under `tsc/` - clean +- `go test ./internal/testrunner/ -run TestLocal` - passes with updated baselines +- `go test ./...` - 62 packages pass; `internal/astnav` fails on a missing + `node_modules/typescript`, confirmed identical with the fix stashed +- `gofmt -l` clean, `go vet ./internal/transformers/...` clean +- Built the patched compiler and diffed real emit/runtime before and after + +Not run: `npx hereby test` / `lint` / `check:format`, because npm dependencies were not +installed in the build environment. Run these before submitting. + +## Why you submit this + +microsoft/TypeScript `CONTRIBUTING.md` states that a pull request is acceptable only if +"a specific human operator has chosen this specific issue, intends to shepherd the change +through review themselves, and will be the one responding to feedback in their own +personal workflow." It also requires that AI assistance be disclosed in the PR +description, and closes undisclosed AI-authored PRs without review. `PR_BODY.md` contains +that disclosure - keep it. + +So: read the diff until you can defend it, then submit it yourself and answer review +yourself. That is the path the project actually accepts. + +## Steps + +1. Read `fix.patch` and make sure you can explain why `1 / 0` is correct and why the + identifier form was not. +2. Fork `microsoft/TypeScript`, clone your fork, branch. +3. `git am < fix.patch` (or `git apply`), rebase onto current `main`, re-run the tests + above plus the `hereby` wrappers. +4. Push and open the PR using `PR_BODY.md`. +5. Note the PR template requires an associated issue in the `Backlog` milestone; #55091 + is currently `Dormant`. Expect maintainers to re-milestone it or to say the change is + not wanted right now - that is a real possibility worth accepting up front. + +## Honest assessment + +Merge probability is moderate, not high. In favour: the bug is real, silent, reproducible +on the shipping compiler, the fix is small, and the approach has precedent. Against: a +maintainer called this scenario unlikely on the earlier PR, the issue sits in `Dormant`, +and the emit-readability tradeoff may draw a request to make it conditional. It is a +legitimate contribution either way. diff --git a/contrib/typescript-55091/fix.patch b/contrib/typescript-55091/fix.patch new file mode 100644 index 0000000..1e55f5e --- /dev/null +++ b/contrib/typescript-55091/fix.patch @@ -0,0 +1,355 @@ +From f02ee807902a4622c79b606641524f21c6ad0843 Mon Sep 17 00:00:00 2001 +From: Vaibhav Lalwani +Date: Fri, 28 Aug 2026 10:52:46 +0000 +Subject: [PATCH] Emit non-finite enum constants as arithmetic instead of + global identifiers + +Enum members whose initializers evaluate to Infinity, -Infinity, or NaN were +emitted as the global identifiers of those names. Identifiers resolve in the +scope of the emitted code, so a local binding shadowing Infinity or NaN changed +the enum member's value at runtime with no diagnostic. + +Emit 1 / 0, -1 / 0, and 0 / 0 instead, which evaluate to the same values and +cannot be shadowed. + +Fixes #55091 +--- + .../transformers/tstransforms/utilities.go | 35 ++++++++--- + .../compiler/enumAutoIncrementValue.js | 4 +- + .../reference/compiler/enumNaNValues.js | 6 +- + .../reference/compiler/fakeInfinity2.js | 4 +- + .../reference/compiler/fakeInfinity3.js | 4 +- + .../enumComputedNonFiniteShadowed.js | 41 +++++++++++++ + .../enumComputedNonFiniteShadowed.symbols | 39 ++++++++++++ + .../enumComputedNonFiniteShadowed.types | 61 +++++++++++++++++++ + .../conformance/enumConstantMembers.js | 14 ++--- + .../enums/enumComputedNonFiniteShadowed.ts | 18 ++++++ + 10 files changed, 202 insertions(+), 24 deletions(-) + create mode 100644 tsc/testdata/baselines/reference/conformance/enumComputedNonFiniteShadowed.js + create mode 100644 tsc/testdata/baselines/reference/conformance/enumComputedNonFiniteShadowed.symbols + create mode 100644 tsc/testdata/baselines/reference/conformance/enumComputedNonFiniteShadowed.types + create mode 100644 tsc/testdata/tests/cases/conformance/enums/enumComputedNonFiniteShadowed.ts + +diff --git a/tsc/internal/transformers/tstransforms/utilities.go b/tsc/internal/transformers/tstransforms/utilities.go +index 2c0f0eb5..c198200d 100644 +--- a/tsc/internal/transformers/tstransforms/utilities.go ++++ b/tsc/internal/transformers/tstransforms/utilities.go +@@ -11,14 +11,8 @@ func constantExpression(value any, factory *printer.NodeFactory) *ast.Expression + case string: + return factory.NewStringLiteral(value, ast.TokenFlagsNone) + case jsnum.Number: +- if value.IsInf() { +- if value > 0 { +- return factory.NewIdentifier("Infinity") +- } +- return factory.NewPrefixUnaryExpression(ast.KindMinusToken, factory.NewIdentifier("Infinity")) +- } +- if value.IsNaN() { +- return factory.NewIdentifier("NaN") ++ if value.IsInf() || value.IsNaN() { ++ return nonFiniteExpression(value, factory) + } + if value < 0 { + return factory.NewPrefixUnaryExpression(ast.KindMinusToken, constantExpression(-value, factory)) +@@ -27,3 +21,28 @@ func constantExpression(value any, factory *printer.NodeFactory) *ast.Expression + } + return nil + } ++ ++// nonFiniteExpression builds an expression evaluating to Infinity, -Infinity, or NaN. ++// These values have no numeric literal form, so they used to be emitted as the global ++// identifiers of the same name. Those identifiers resolve in the scope of the emitted ++// code rather than at the enum declaration, so a local binding that shadows them ++// silently changes the constant's value at runtime. Division by zero has no such ++// dependency on the surrounding scope. ++func nonFiniteExpression(value jsnum.Number, factory *printer.NodeFactory) *ast.Expression { ++ var numerator *ast.Expression ++ switch { ++ case value.IsNaN(): ++ numerator = factory.NewNumericLiteral("0", ast.TokenFlagsNone) ++ case value > 0: ++ numerator = factory.NewNumericLiteral("1", ast.TokenFlagsNone) ++ default: ++ numerator = factory.NewPrefixUnaryExpression(ast.KindMinusToken, factory.NewNumericLiteral("1", ast.TokenFlagsNone)) ++ } ++ return factory.NewBinaryExpression( ++ nil, /*modifiers*/ ++ numerator, ++ nil, /*typeNode*/ ++ factory.NewToken(ast.KindSlashToken), ++ factory.NewNumericLiteral("0", ast.TokenFlagsNone), ++ ) ++} +diff --git a/tsc/testdata/baselines/reference/compiler/enumAutoIncrementValue.js b/tsc/testdata/baselines/reference/compiler/enumAutoIncrementValue.js +index d42086ad..e2f405d5 100644 +--- a/tsc/testdata/baselines/reference/compiler/enumAutoIncrementValue.js ++++ b/tsc/testdata/baselines/reference/compiler/enumAutoIncrementValue.js +@@ -11,6 +11,6 @@ enum E { + "use strict"; + var E; + (function (E) { +- E[E["A"] = NaN] = "A"; +- E[E["B"] = NaN] = "B"; ++ E[E["A"] = 0 / 0] = "A"; ++ E[E["B"] = 0 / 0] = "B"; + })(E || (E = {})); +diff --git a/tsc/testdata/baselines/reference/compiler/enumNaNValues.js b/tsc/testdata/baselines/reference/compiler/enumNaNValues.js +index 88ba034c..a3964c6f 100644 +--- a/tsc/testdata/baselines/reference/compiler/enumNaNValues.js ++++ b/tsc/testdata/baselines/reference/compiler/enumNaNValues.js +@@ -20,13 +20,13 @@ const c: E.A = F.X; // Error expected - different enums + "use strict"; + var E; + (function (E) { +- E[E["A"] = NaN] = "A"; +- E[E["B"] = NaN] = "B"; ++ E[E["A"] = 0 / 0] = "A"; ++ E[E["B"] = 0 / 0] = "B"; + })(E || (E = {})); + const a = E.B; + const b = E.A; + var F; + (function (F) { +- F[F["X"] = NaN] = "X"; ++ F[F["X"] = 0 / 0] = "X"; + })(F || (F = {})); + const c = F.X; // Error expected - different enums +diff --git a/tsc/testdata/baselines/reference/compiler/fakeInfinity2.js b/tsc/testdata/baselines/reference/compiler/fakeInfinity2.js +index 6c2bf804..aca281aa 100644 +--- a/tsc/testdata/baselines/reference/compiler/fakeInfinity2.js ++++ b/tsc/testdata/baselines/reference/compiler/fakeInfinity2.js +@@ -21,8 +21,8 @@ export const m = X.f(); + //// [fakeInfinity2.js] + export var Foo; + (function (Foo) { +- Foo[Foo["A"] = Infinity] = "A"; +- Foo[Foo["B"] = -Infinity] = "B"; ++ Foo[Foo["A"] = 1 / 0] = "A"; ++ Foo[Foo["B"] = -1 / 0] = "B"; + })(Foo || (Foo = {})); + var X; + (function (X) { +diff --git a/tsc/testdata/baselines/reference/compiler/fakeInfinity3.js b/tsc/testdata/baselines/reference/compiler/fakeInfinity3.js +index dbde9c2c..5ac9f6a1 100644 +--- a/tsc/testdata/baselines/reference/compiler/fakeInfinity3.js ++++ b/tsc/testdata/baselines/reference/compiler/fakeInfinity3.js +@@ -26,8 +26,8 @@ Object.defineProperty(exports, "__esModule", { value: true }); + exports.Infinity = exports.m = exports.Foo = void 0; + var Foo; + (function (Foo) { +- Foo[Foo["A"] = Infinity] = "A"; +- Foo[Foo["B"] = -Infinity] = "B"; ++ Foo[Foo["A"] = 1 / 0] = "A"; ++ Foo[Foo["B"] = -1 / 0] = "B"; + })(Foo || (exports.Foo = Foo = {})); + var X; + (function (X) { +diff --git a/tsc/testdata/baselines/reference/conformance/enumComputedNonFiniteShadowed.js b/tsc/testdata/baselines/reference/conformance/enumComputedNonFiniteShadowed.js +new file mode 100644 +index 00000000..fb4139b0 +--- /dev/null ++++ b/tsc/testdata/baselines/reference/conformance/enumComputedNonFiniteShadowed.js +@@ -0,0 +1,41 @@ ++//// [tests/cases/conformance/enums/enumComputedNonFiniteShadowed.ts] //// ++ ++//// [enumComputedNonFiniteShadowed.ts] ++// https://github.com/microsoft/TypeScript/issues/55091 ++ ++{ ++ let Infinity = 3; ++ let NaN = 7; ++ enum En { ++ Pos = 1 / 0, ++ Neg = -1 / 0, ++ Nan = 0 / 0, ++ } ++} ++ ++enum NotShadowed { ++ Pos = 1 / 0, ++ Neg = -1 / 0, ++ Nan = 0 / 0, ++} ++ ++ ++//// [enumComputedNonFiniteShadowed.js] ++"use strict"; ++// https://github.com/microsoft/TypeScript/issues/55091 ++{ ++ let Infinity = 3; ++ let NaN = 7; ++ let En; ++ (function (En) { ++ En[En["Pos"] = 1 / 0] = "Pos"; ++ En[En["Neg"] = -1 / 0] = "Neg"; ++ En[En["Nan"] = 0 / 0] = "Nan"; ++ })(En || (En = {})); ++} ++var NotShadowed; ++(function (NotShadowed) { ++ NotShadowed[NotShadowed["Pos"] = 1 / 0] = "Pos"; ++ NotShadowed[NotShadowed["Neg"] = -1 / 0] = "Neg"; ++ NotShadowed[NotShadowed["Nan"] = 0 / 0] = "Nan"; ++})(NotShadowed || (NotShadowed = {})); +diff --git a/tsc/testdata/baselines/reference/conformance/enumComputedNonFiniteShadowed.symbols b/tsc/testdata/baselines/reference/conformance/enumComputedNonFiniteShadowed.symbols +new file mode 100644 +index 00000000..28825188 +--- /dev/null ++++ b/tsc/testdata/baselines/reference/conformance/enumComputedNonFiniteShadowed.symbols +@@ -0,0 +1,39 @@ ++//// [tests/cases/conformance/enums/enumComputedNonFiniteShadowed.ts] //// ++ ++=== enumComputedNonFiniteShadowed.ts === ++// https://github.com/microsoft/TypeScript/issues/55091 ++ ++{ ++ let Infinity = 3; ++>Infinity : Symbol(Infinity, Decl(enumComputedNonFiniteShadowed.ts, 3, 5)) ++ ++ let NaN = 7; ++>NaN : Symbol(NaN, Decl(enumComputedNonFiniteShadowed.ts, 4, 5)) ++ ++ enum En { ++>En : Symbol(En, Decl(enumComputedNonFiniteShadowed.ts, 4, 14)) ++ ++ Pos = 1 / 0, ++>Pos : Symbol(En.Pos, Decl(enumComputedNonFiniteShadowed.ts, 5, 11)) ++ ++ Neg = -1 / 0, ++>Neg : Symbol(En.Neg, Decl(enumComputedNonFiniteShadowed.ts, 6, 16)) ++ ++ Nan = 0 / 0, ++>Nan : Symbol(En.Nan, Decl(enumComputedNonFiniteShadowed.ts, 7, 17)) ++ } ++} ++ ++enum NotShadowed { ++>NotShadowed : Symbol(NotShadowed, Decl(enumComputedNonFiniteShadowed.ts, 10, 1)) ++ ++ Pos = 1 / 0, ++>Pos : Symbol(NotShadowed.Pos, Decl(enumComputedNonFiniteShadowed.ts, 12, 18)) ++ ++ Neg = -1 / 0, ++>Neg : Symbol(NotShadowed.Neg, Decl(enumComputedNonFiniteShadowed.ts, 13, 14)) ++ ++ Nan = 0 / 0, ++>Nan : Symbol(NotShadowed.Nan, Decl(enumComputedNonFiniteShadowed.ts, 14, 15)) ++} ++ +diff --git a/tsc/testdata/baselines/reference/conformance/enumComputedNonFiniteShadowed.types b/tsc/testdata/baselines/reference/conformance/enumComputedNonFiniteShadowed.types +new file mode 100644 +index 00000000..a3b71a39 +--- /dev/null ++++ b/tsc/testdata/baselines/reference/conformance/enumComputedNonFiniteShadowed.types +@@ -0,0 +1,61 @@ ++//// [tests/cases/conformance/enums/enumComputedNonFiniteShadowed.ts] //// ++ ++=== enumComputedNonFiniteShadowed.ts === ++// https://github.com/microsoft/TypeScript/issues/55091 ++ ++{ ++ let Infinity = 3; ++>Infinity : number ++>3 : 3 ++ ++ let NaN = 7; ++>NaN : number ++>7 : 7 ++ ++ enum En { ++>En : En ++ ++ Pos = 1 / 0, ++>Pos : En.Pos ++>1 / 0 : number ++>1 : 1 ++>0 : 0 ++ ++ Neg = -1 / 0, ++>Neg : En.Neg ++>-1 / 0 : number ++>-1 : -1 ++>1 : 1 ++>0 : 0 ++ ++ Nan = 0 / 0, ++>Nan : En.Nan ++>0 / 0 : number ++>0 : 0 ++>0 : 0 ++ } ++} ++ ++enum NotShadowed { ++>NotShadowed : NotShadowed ++ ++ Pos = 1 / 0, ++>Pos : NotShadowed.Pos ++>1 / 0 : number ++>1 : 1 ++>0 : 0 ++ ++ Neg = -1 / 0, ++>Neg : NotShadowed.Neg ++>-1 / 0 : number ++>-1 : -1 ++>1 : 1 ++>0 : 0 ++ ++ Nan = 0 / 0, ++>Nan : NotShadowed.Nan ++>0 / 0 : number ++>0 : 0 ++>0 : 0 ++} ++ +diff --git a/tsc/testdata/baselines/reference/conformance/enumConstantMembers.js b/tsc/testdata/baselines/reference/conformance/enumConstantMembers.js +index f38cf9b6..0868cadf 100644 +--- a/tsc/testdata/baselines/reference/conformance/enumConstantMembers.js ++++ b/tsc/testdata/baselines/reference/conformance/enumConstantMembers.js +@@ -62,11 +62,11 @@ var E3; + })(E3 || (E3 = {})); + var E5; + (function (E5) { +- E5[E5["a"] = Infinity] = "a"; +- E5[E5["b"] = Infinity] = "b"; +- E5[E5["c"] = Infinity] = "c"; +- E5[E5["d"] = NaN] = "d"; +- E5[E5["e"] = NaN] = "e"; +- E5[E5["f"] = Infinity] = "f"; +- E5[E5["g"] = -Infinity] = "g"; ++ E5[E5["a"] = 1 / 0] = "a"; ++ E5[E5["b"] = 1 / 0] = "b"; ++ E5[E5["c"] = 1 / 0] = "c"; ++ E5[E5["d"] = 0 / 0] = "d"; ++ E5[E5["e"] = 0 / 0] = "e"; ++ E5[E5["f"] = 1 / 0] = "f"; ++ E5[E5["g"] = -1 / 0] = "g"; + })(E5 || (E5 = {})); +diff --git a/tsc/testdata/tests/cases/conformance/enums/enumComputedNonFiniteShadowed.ts b/tsc/testdata/tests/cases/conformance/enums/enumComputedNonFiniteShadowed.ts +new file mode 100644 +index 00000000..2dadfd7c +--- /dev/null ++++ b/tsc/testdata/tests/cases/conformance/enums/enumComputedNonFiniteShadowed.ts +@@ -0,0 +1,18 @@ ++// @target: es2015 ++// https://github.com/microsoft/TypeScript/issues/55091 ++ ++{ ++ let Infinity = 3; ++ let NaN = 7; ++ enum En { ++ Pos = 1 / 0, ++ Neg = -1 / 0, ++ Nan = 0 / 0, ++ } ++} ++ ++enum NotShadowed { ++ Pos = 1 / 0, ++ Neg = -1 / 0, ++ Nan = 0 / 0, ++} +-- +2.43.0 + From a3b75986f33f5e167b81679820c814b613bccb4f Mon Sep 17 00:00:00 2001 From: Vaibhav Lalwani Date: Fri, 28 Aug 2026 11:00:56 +0000 Subject: [PATCH 2/2] Pin nanoid to the 3.3.18 patched release GHSA-2v37-7h3g-55p8 raised the patched floor for nanoid to >=3.3.18, so the 3.3.17 override pinned in #35 now fails the production dependency audit. The advisory reaches the graph transitively through next > postcss > nanoid. Bump the existing override in pnpm-workspace.yaml, keep package.json in sync, and regenerate the lockfile. --- package.json | 2 +- pnpm-lock.yaml | 10 +++++----- pnpm-workspace.yaml | 2 +- 3 files changed, 7 insertions(+), 7 deletions(-) diff --git a/package.json b/package.json index e8a683e..bc7e3fd 100644 --- a/package.json +++ b/package.json @@ -89,7 +89,7 @@ "fast-uri": "3.1.5", "hono": "4.13.0", "js-yaml": "4.3.1", - "nanoid": "3.3.17", + "nanoid": "3.3.18", "postcss": "8.5.25", "undici": "7.29.0" }, diff --git a/pnpm-lock.yaml b/pnpm-lock.yaml index ead69f2..31e494b 100644 --- a/pnpm-lock.yaml +++ b/pnpm-lock.yaml @@ -9,7 +9,7 @@ overrides: fast-uri: 3.1.5 hono: 4.13.0 js-yaml: 4.3.1 - nanoid: 3.3.17 + nanoid: 3.3.18 postcss: 8.5.25 undici: 7.29.0 @@ -2930,8 +2930,8 @@ packages: ms@2.1.3: resolution: {integrity: sha512-6FlzubTLZG3J2a/NVCAleEhjzq5oxgHyaCU9yYXvcLsvoVaHJq/s5xXI6/XXP6tz7R9xAOtHnSO/tXtF3WRTlA==} - nanoid@3.3.17: - resolution: {integrity: sha512-xQLf0A3HOMlgHq0n247/LRuAOYmB7dXJ/DvAxGvsSBij45XtBSmQycu+F8ODbHwns/XyFZagyL1+J0Offw1E0g==} + nanoid@3.3.18: + resolution: {integrity: sha512-DTg4MJbGMWkfi6VZFdNt2/caMbQy4Ou+Op/hJQvGEWcnVfoA1QA+xzRKAzw9jD6+GVOOeYr/mIcuDSdug6F6+w==} engines: {node: ^10 || ^12 || ^13.7 || ^14 || >=15.0.1} hasBin: true @@ -6263,7 +6263,7 @@ snapshots: ms@2.1.3: {} - nanoid@3.3.17: {} + nanoid@3.3.18: {} napi-postinstall@0.3.4: {} @@ -6433,7 +6433,7 @@ snapshots: postcss@8.5.25: dependencies: - nanoid: 3.3.17 + nanoid: 3.3.18 picocolors: 1.1.1 source-map-js: 1.2.1 diff --git a/pnpm-workspace.yaml b/pnpm-workspace.yaml index e43be14..4e1426e 100644 --- a/pnpm-workspace.yaml +++ b/pnpm-workspace.yaml @@ -14,6 +14,6 @@ overrides: fast-uri: 3.1.5 hono: 4.13.0 js-yaml: 4.3.1 - nanoid: 3.3.17 + nanoid: 3.3.18 postcss: 8.5.25 undici: 7.29.0