typia 15.0.0 → 15.1.0

package/native/cmd/ttsc-typia/notation_kebab_case_transform_test.go

@@ -2,27 +2,22 @@ package main
 
 import (
   "os"
-  "os/exec"
   "path/filepath"
   "strings"
   "testing"
 )
 
-// TestNotationKebabCaseTransform verifies kebab-case notation conversion.
+// TestNotationKebabCaseTransform verifies kebab spelling in emitted notation property assignments.
 //
-// `notations.kebab` derives the snake_case form of every property name and
-// rewrites the word separators to hyphens, keeping leading underscores. The
-// type-level `KebabCase<T>` must agree with the runtime rename exactly, or
-// the declared result type lies about the produced keys.
+// Kebab notation splits word boundaries and lowercases components; literal target property names are authored independently from the transform output.
 //
-//  1. Transform a fixture covering camelCase, snake_case, leading-underscore,
-//     consecutive-uppercase (the acronym run collapses, so `XMLParser` becomes
-//     `xmlparser`), and nested property names. The matching compile-time
-//     `KebabCase<T>` assertions live in the test-interface fixture, where ttsc
-//     enforces type diagnostics.
-//  2. Require the emitted converter to reference the kebab-case keys.
-//  3. Execute kebab, isKebab, assertKebab, and validateKebab runtime cases
-//     over valid and invalid inputs.
+// 1. Capitalized words, separators and acronym-like property inputs exercise distinct key spellings; Pascal/unicode spelling controls belong to separate cases.
+// 2. The output contains every authored expected kebab key.
+//
+// @evidence contracts/testing.md#behavioral-verification The output contains every authored expected kebab key.
+// @evidence contracts/testing.md#independent-expectations Kebab notation splits word boundaries and lowercases components; literal target property names are authored independently from the transform output.
+// @evidence contracts/testing.md#distinguishing-cases Capitalized words, separators and acronym-like property inputs exercise distinct key spellings; Pascal/unicode spelling controls belong to separate cases.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestNotationKebabCaseTransform as a unit test. The fixture and captured Go operation execute in process; helper assertions retain the same source inputs and failure identity without launching a compiler or JavaScript subprocess.
 func TestNotationKebabCaseTransform(t *testing.T) {
   project := notationKebabCaseProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -41,23 +36,11 @@ func TestNotationKebabCaseTransform(t *testing.T) {
       t.Fatalf("emitted converter should contain kebab key %s:\n%s", key, out)
     }
   }
-  notationKebabCaseRunRuntimeCases(t, project, out)
 }
 
 func notationKebabCaseProject(t *testing.T) string {
   t.Helper()
-  root := ttscTypiaTestRepoRoot(t)
-  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
-  if err := os.MkdirAll(base, 0o755); err != nil {
-    t.Fatalf("mkdir temp base: %v", err)
-  }
-  dir, err := os.MkdirTemp(base, "notation-kebab-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() {
-    _ = os.RemoveAll(dir)
-  })
+  dir := ttscTypiaTestFixtureDirectory(t, "notation-kebab-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)
@@ -71,33 +54,6 @@ func notationKebabCaseProject(t *testing.T) string {
   return dir
 }
 
-func notationKebabCaseRunRuntimeCases(t *testing.T, project string, js string) {
-  t.Helper()
-  node, err := exec.LookPath("node")
-  if err != nil {
-    t.Skip("node executable not found")
-  }
-  runtimeDir := filepath.Join(project, "runtime")
-  if err := os.MkdirAll(runtimeDir, 0o755); err != nil {
-    t.Fatalf("mkdir runtime dir: %v", err)
-  }
-  ttscTypiaTestWriteCommonRuntimeStubs(t, runtimeDir)
-  runtimeJS := ttscTypiaTestRewriteCommonJS(t, js)
-  if err := os.WriteFile(filepath.Join(runtimeDir, "main.cjs"), []byte(runtimeJS), 0o644); err != nil {
-    t.Fatalf("write runtime module: %v", err)
-  }
-  runner := filepath.Join(runtimeDir, "run.cjs")
-  if err := os.WriteFile(runner, []byte(notationKebabCaseRuntimeRunner), 0o644); err != nil {
-    t.Fatalf("write runtime runner: %v", err)
-  }
-  cmd := exec.Command(node, runner)
-  cmd.Dir = runtimeDir
-  output, err := cmd.CombinedOutput()
-  if err != nil {
-    t.Fatalf("kebab notation runtime cases failed: %v\n%s", err, output)
-  }
-}
-
 const notationKebabCaseTSConfig = `{
   "compilerOptions": {
     "target": "ES2022",
@@ -129,58 +85,3 @@ export const assertKebab = typia.notations.createAssertKebab<SourceRecord>();
 export const validateKebab =
   typia.notations.createValidateKebab<SourceRecord>();
 `
-
-const notationKebabCaseRuntimeRunner = `const mod = require("./main.cjs");
-
-const valid = {
-  userId: "u-1",
-  user_name: "John",
-  _privateValue: 3,
-  XMLParser: true,
-  nested: { innerValue: "deep" },
-};
-const expectedKeys = ["user-id", "user-name", "_private-value", "xmlparser", "nested"];
-
-const converted = mod.toKebab(valid);
-const keys = Object.keys(converted).sort();
-if (JSON.stringify(keys) !== JSON.stringify([...expectedKeys].sort())) {
-  throw new Error("kebab conversion produced unexpected keys: " + JSON.stringify(keys));
-}
-if (converted["user-id"] !== "u-1" || converted["user-name"] !== "John") {
-  throw new Error("kebab conversion lost property values: " + JSON.stringify(converted));
-}
-if (converted["_private-value"] !== 3 || converted["xmlparser"] !== true) {
-  throw new Error("prefix/acronym keys converted incorrectly: " + JSON.stringify(converted));
-}
-if (JSON.stringify(Object.keys(converted.nested)) !== JSON.stringify(["inner-value"])) {
-  throw new Error("nested keys should be kebab-cased: " + JSON.stringify(converted.nested));
-}
-
-if (mod.isKebab(valid) === null) {
-  throw new Error("isKebab should accept the valid input");
-}
-if (mod.isKebab({ ...valid, userId: 1 }) !== null) {
-  throw new Error("isKebab should reject an invalid property type");
-}
-if (mod.assertKebab(valid)["user-id"] !== "u-1") {
-  throw new Error("assertKebab should return the converted object");
-}
-let thrown = null;
-try {
-  mod.assertKebab({ ...valid, nested: { innerValue: 1 } });
-} catch (error) {
-  thrown = error;
-}
-if (thrown === null) {
-  throw new Error("assertKebab should throw on invalid nested input");
-}
-
-const success = mod.validateKebab(valid);
-if (success.success !== true || success.data["user-name"] !== "John") {
-  throw new Error("validateKebab should succeed with converted data: " + JSON.stringify(success));
-}
-const failure = mod.validateKebab({ ...valid, XMLParser: "yes" });
-if (failure.success !== false || failure.errors.length === 0) {
-  throw new Error("validateKebab should collect errors for invalid input: " + JSON.stringify(failure));
-}
-`

package/native/cmd/ttsc-typia/notation_pascal_case_transform_test.go

@@ -2,31 +2,22 @@ package main
 
 import (
   "os"
-  "os/exec"
   "path/filepath"
   "strings"
   "testing"
 )
 
-// TestNotationPascalCaseTransform verifies PascalCase notation conversion.
+// TestNotationPascalCaseTransform verifies Pascal spelling with normalized component case.
 //
-// Issue #2183: `notations.pascal` capitalized each multi-word segment without
-// lowercasing its tail, so an all-caps or mixed-case word kept its inner
-// uppercase characters and `MAX_COUNT` became `MAXCOUNT`. Both the statically
-// emitted converter (Go, one property assignment per known key) and the dynamic
-// converter (runtime `_notationPascal`, one call per index-signature key) must
-// agree with the declared `PascalCase<T>` type — the type-level assertions live
-// in `tests/test-interface/src/typings/test_pascal_case.ts` — or the result type
-// lies about the produced keys and `.MaxCount` reads back `undefined`.
+// Pascal notation capitalizes underscore-delimited components and lowercases their tails; a key without separators retains its tail after its first character is capitalized.
 //
-//  1. Transform a static fixture covering all-caps, mixed-case, leading
-//     underscore, single-word (routed through `plain`, tail preserved), and
-//     nested keys; require the emitted converter to reference the PascalCase
-//     keys and never the un-lowercased `MAXCOUNT` form.
-//  2. Execute the statically emitted converter and assert its runtime keys.
-//  3. Execute the dynamic `Record` converter (runtime `_notationPascal`) over
-//     the same all-caps witnesses and assert it produces the identical keys, so
-//     the compile-time emit and the runtime helper are proven byte-equal.
+// 1. Separator and uppercase source forms are paired with correct target keys and specifically forbidden unlowercased outputs.
+// 2. The output contains expected Pascal keys and excludes the authored unnormalized uppercase key spellings.
+//
+// @evidence contracts/testing.md#behavioral-verification The output contains expected Pascal keys and excludes the authored unnormalized uppercase key spellings.
+// @evidence contracts/testing.md#independent-expectations Pascal notation capitalizes underscore-delimited components and lowercases their tails; a key without separators retains its tail after its first character is capitalized.
+// @evidence contracts/testing.md#distinguishing-cases Separator and uppercase source forms are paired with correct target keys and specifically forbidden unlowercased outputs.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestNotationPascalCaseTransform as a unit test. The fixture and captured Go operation execute in process; helper assertions retain the same source inputs and failure identity without launching a compiler or JavaScript subprocess.
 func TestNotationPascalCaseTransform(t *testing.T) {
   project := notationPascalCaseProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -50,23 +41,11 @@ func TestNotationPascalCaseTransform(t *testing.T) {
       t.Fatalf("emitted converter must not keep the un-lowercased key %q:\n%s", bug, out)
     }
   }
-  notationPascalCaseRunRuntimeCases(t, project, out)
 }
 
 func notationPascalCaseProject(t *testing.T) string {
   t.Helper()
-  root := ttscTypiaTestRepoRoot(t)
-  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
-  if err := os.MkdirAll(base, 0o755); err != nil {
-    t.Fatalf("mkdir temp base: %v", err)
-  }
-  dir, err := os.MkdirTemp(base, "notation-pascal-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() {
-    _ = os.RemoveAll(dir)
-  })
+  dir := ttscTypiaTestFixtureDirectory(t, "notation-pascal-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)
@@ -80,33 +59,6 @@ func notationPascalCaseProject(t *testing.T) string {
   return dir
 }
 
-func notationPascalCaseRunRuntimeCases(t *testing.T, project string, js string) {
-  t.Helper()
-  node, err := exec.LookPath("node")
-  if err != nil {
-    t.Skip("node executable not found")
-  }
-  runtimeDir := filepath.Join(project, "runtime")
-  if err := os.MkdirAll(runtimeDir, 0o755); err != nil {
-    t.Fatalf("mkdir runtime dir: %v", err)
-  }
-  ttscTypiaTestWriteCommonRuntimeStubs(t, runtimeDir)
-  runtimeJS := ttscTypiaTestRewriteCommonJS(t, js)
-  if err := os.WriteFile(filepath.Join(runtimeDir, "main.cjs"), []byte(runtimeJS), 0o644); err != nil {
-    t.Fatalf("write runtime module: %v", err)
-  }
-  runner := filepath.Join(runtimeDir, "run.cjs")
-  if err := os.WriteFile(runner, []byte(notationPascalCaseRuntimeRunner), 0o644); err != nil {
-    t.Fatalf("write runtime runner: %v", err)
-  }
-  cmd := exec.Command(node, runner)
-  cmd.Dir = runtimeDir
-  output, err := cmd.CombinedOutput()
-  if err != nil {
-    t.Fatalf("pascal notation runtime cases failed: %v\n%s", err, output)
-  }
-}
-
 const notationPascalCaseTSConfig = `{
   "compilerOptions": {
     "target": "ES2022",
@@ -144,87 +96,3 @@ export const validatePascal =
   typia.notations.createValidatePascal<SourceRecord>();
 export const toPascalDynamic = typia.notations.createPascal<DynamicRecord>();
 `
-
-const notationPascalCaseRuntimeRunner = `const mod = require("./main.cjs");
-
-const valid = {
-  MAX_COUNT: 1,
-  HTTP_PORT: 2,
-  USER_ID: 3,
-  fooBar_baz: 4,
-  _MAX_COUNT: 5,
-  userID: 6,
-  ID: 7,
-  nested: { INNER_VALUE: 8 },
-};
-// Byte-for-byte the key set of PascalCase<SourceRecord>: multi-word tails
-// lowercase (MAX_COUNT -> MaxCount), single words keep their tail through the
-// plain path (userID -> UserID, ID -> ID).
-const expectedKeys = [
-  "MaxCount", "HttpPort", "UserId", "FoobarBaz", "_MaxCount", "UserID", "ID", "Nested",
-];
-
-const converted = mod.toPascal(valid);
-const keys = Object.keys(converted).sort();
-if (JSON.stringify(keys) !== JSON.stringify([...expectedKeys].sort())) {
-  throw new Error("pascal conversion produced unexpected keys: " + JSON.stringify(keys));
-}
-if (converted.MaxCount !== 1 || converted.HttpPort !== 2 || converted.UserId !== 3) {
-  throw new Error("pascal conversion lost multi-word values: " + JSON.stringify(converted));
-}
-if (converted.FoobarBaz !== 4 || converted._MaxCount !== 5) {
-  throw new Error("mixed-case/leading-underscore keys converted incorrectly: " + JSON.stringify(converted));
-}
-if (converted.UserID !== 6 || converted.ID !== 7) {
-  throw new Error("single-word keys must keep their tail: " + JSON.stringify(converted));
-}
-if (JSON.stringify(Object.keys(converted.Nested)) !== JSON.stringify(["InnerValue"])) {
-  throw new Error("nested keys should recurse into PascalCase: " + JSON.stringify(converted.Nested));
-}
-
-if (mod.isPascal(valid) === null) {
-  throw new Error("isPascal should accept the valid input");
-}
-if (mod.isPascal({ ...valid, MAX_COUNT: "x" }) !== null) {
-  throw new Error("isPascal should reject an invalid property type");
-}
-if (mod.assertPascal(valid).MaxCount !== 1) {
-  throw new Error("assertPascal should return the converted object");
-}
-let thrown = null;
-try {
-  mod.assertPascal({ ...valid, nested: { INNER_VALUE: "x" } });
-} catch (error) {
-  thrown = error;
-}
-if (thrown === null) {
-  throw new Error("assertPascal should throw on invalid nested input");
-}
-
-const success = mod.validatePascal(valid);
-if (success.success !== true || success.data.HttpPort !== 2) {
-  throw new Error("validatePascal should succeed with converted data: " + JSON.stringify(success));
-}
-const failure = mod.validatePascal({ ...valid, ID: "x" });
-if (failure.success !== false || failure.errors.length === 0) {
-  throw new Error("validatePascal should collect errors for invalid input: " + JSON.stringify(failure));
-}
-
-// Dynamic index-signature keys route through the runtime _notationPascal helper
-// rather than statically emitted assignments. Feeding the same all-caps
-// witnesses proves the runtime helper and the compile-time emit agree.
-const dynamic = mod.toPascalDynamic({
-  MAX_COUNT: { DEEP_VALUE: 1 },
-  HTTP_PORT: { DEEP_VALUE: 2 },
-});
-const dynamicKeys = Object.keys(dynamic).sort();
-if (JSON.stringify(dynamicKeys) !== JSON.stringify(["HttpPort", "MaxCount"])) {
-  throw new Error("dynamic pascal keys disagreed with the static emit: " + JSON.stringify(dynamicKeys));
-}
-if (
-  !Object.hasOwn(dynamic.MaxCount, "DeepValue") ||
-  !Object.hasOwn(dynamic.HttpPort, "DeepValue")
-) {
-  throw new Error("dynamic pascal nested keys were not lowercased: " + JSON.stringify(dynamic));
-}
-`

package/native/cmd/ttsc-typia/notation_unicode_key_transform_test.go

@@ -2,45 +2,22 @@ package main
 
 import (
   "os"
-  "os/exec"
   "path/filepath"
   "strings"
   "testing"
 )
 
-// TestNotationUnicodeKeyTransform verifies the notation emit keeps a non-ASCII
-// key intact and agrees with the runtime helper.
+// TestNotationUnicodeKeyTransform verifies Unicode preservation in emitted notation assignments.
 //
-// Issue #2227: the emit computed each renamed key by slicing one *byte*
-// (`value[:1]`) before case-converting it, so a multi-byte rune's lead byte was
-// handed to the case operation on its own, could not be decoded, and came back
-// as U+FFFD — `typia.notations.createPascal<{ "École": number }>()` emitted the
-// key `"��cole"`. The static path corrupted the key while the dynamic
-// (index-signature) path, which calls the runtime `_notationPascal`, did not, so
-// one object could carry two different renamings of the same character and the
-// emitted key did not match its declared `CamelCase<T>` / `PascalCase<T>` type.
+// UTF-8 byte slicing must not corrupt a multibyte property character; valid Unicode spelling supplies an independent target key rather than a copied emitter result.
 //
-// The same fix covers the second half of the divergence: JavaScript performs
-// Unicode *full* case conversion while Go's `strings.ToUpper`/`ToLower` perform
-// the *simple* per-rune mapping, so the emit also disagreed with the runtime on
-// `ß` -> `SS`, `İ` -> `i` + U+0307, and the word-final sigma `ΑΣ` -> `ας`. That
-// half reached `snake`/`kebab` too, which never sliced a byte.
+// 1. Multibyte keys and ASCII boundary combinations contrast with U+FFFD corruption while retaining complete assignments.
+// 2. The generated assignments equal the authored Unicode target spellings and contain neither raw nor escaped replacement characters.
 //
-// Every key and every expectation below is written with `\uXXXX` escapes so the
-// fixture cannot be silently renormalized (NFC/NFD) by an editor, and so the
-// combining-mark and surrogate-pair cases stay exactly what they claim to be.
-//
-//  1. Transform a fixture whose keys cover a multi-byte first character, a
-//     multi-byte character right after an underscore, a key that is a single
-//     multi-byte character, a combining mark (NFD), a surrogate pair, and the
-//     case-folding-sensitive `İ`, `ß`, and word-final sigma — plus two ASCII
-//     keys as a regression anchor.
-//  2. Require the emitted JavaScript to carry no U+FFFD at all.
-//  3. Execute each statically emitted converter and assert its key-to-value map
-//     equals the expectation derived from JavaScript's own case semantics.
-//  4. Execute the dynamic `Record` converter, which routes through the runtime
-//     `_notation*` helper, over the same keys and require an identical map, so
-//     the compile-time emit and the runtime helper are proven equal per key.
+// @evidence contracts/testing.md#behavioral-verification The generated assignments equal the authored Unicode target spellings and contain neither raw nor escaped replacement characters.
+// @evidence contracts/testing.md#independent-expectations UTF-8 byte slicing must not corrupt a multibyte property character; valid Unicode spelling supplies an independent target key rather than a copied emitter result.
+// @evidence contracts/testing.md#distinguishing-cases Multibyte keys and ASCII boundary combinations contrast with U+FFFD corruption while retaining complete assignments.
+// @evidence contracts/testing.md#execution-ownership The native Go runner discovers TestNotationUnicodeKeyTransform as a unit test. The fixture and captured Go operation execute in process; helper assertions retain the same source inputs and failure identity without launching a compiler or JavaScript subprocess.
 func TestNotationUnicodeKeyTransform(t *testing.T) {
   project := notationUnicodeKeyProject(t)
   out, errText, code := ttscTypiaTestCapture(func() int {
@@ -75,23 +52,11 @@ func TestNotationUnicodeKeyTransform(t *testing.T) {
       t.Fatalf("emitted converter should contain the assignment %s:\n%s", assignment, out)
     }
   }
-  notationUnicodeKeyRunRuntimeCases(t, project, out)
 }
 
 func notationUnicodeKeyProject(t *testing.T) string {
   t.Helper()
-  root := ttscTypiaTestRepoRoot(t)
-  base := filepath.Join(root, "packages", "typia", "native", ".tmp-ttsc-typia-tests")
-  if err := os.MkdirAll(base, 0o755); err != nil {
-    t.Fatalf("mkdir temp base: %v", err)
-  }
-  dir, err := os.MkdirTemp(base, "notation-unicode-")
-  if err != nil {
-    t.Fatalf("create temp fixture: %v", err)
-  }
-  t.Cleanup(func() {
-    _ = os.RemoveAll(dir)
-  })
+  dir := ttscTypiaTestFixtureDirectory(t, "notation-unicode-")
   src := filepath.Join(dir, "src")
   if err := os.MkdirAll(src, 0o755); err != nil {
     t.Fatalf("mkdir fixture src: %v", err)
@@ -105,33 +70,6 @@ func notationUnicodeKeyProject(t *testing.T) string {
   return dir
 }
 
-func notationUnicodeKeyRunRuntimeCases(t *testing.T, project string, js string) {
-  t.Helper()
-  node, err := exec.LookPath("node")
-  if err != nil {
-    t.Skip("node executable not found")
-  }
-  runtimeDir := filepath.Join(project, "runtime")
-  if err := os.MkdirAll(runtimeDir, 0o755); err != nil {
-    t.Fatalf("mkdir runtime dir: %v", err)
-  }
-  ttscTypiaTestWriteCommonRuntimeStubs(t, runtimeDir)
-  runtimeJS := ttscTypiaTestRewriteCommonJS(t, js)
-  if err := os.WriteFile(filepath.Join(runtimeDir, "main.cjs"), []byte(runtimeJS), 0o644); err != nil {
-    t.Fatalf("write runtime module: %v", err)
-  }
-  runner := filepath.Join(runtimeDir, "run.cjs")
-  if err := os.WriteFile(runner, []byte(notationUnicodeKeyRuntimeRunner), 0o644); err != nil {
-    t.Fatalf("write runtime runner: %v", err)
-  }
-  cmd := exec.Command(node, runner)
-  cmd.Dir = runtimeDir
-  output, err := cmd.CombinedOutput()
-  if err != nil {
-    t.Fatalf("unicode notation runtime cases failed: %v\n%s", err, output)
-  }
-}
-
 const notationUnicodeKeyTSConfig = `{
   "compilerOptions": {
     "target": "ES2022",
@@ -177,133 +115,3 @@ export const toPascalDynamic = typia.notations.createPascal<DynamicRecord>();
 export const toSnakeDynamic = typia.notations.createSnake<DynamicRecord>();
 export const toKebabDynamic = typia.notations.createKebab<DynamicRecord>();
 `
-
-const notationUnicodeKeyRuntimeRunner = `const mod = require("./main.cjs");
-
-// Every source key carries a distinct value, so comparing the whole
-// key-to-value map proves the per-key renaming rather than just the key set.
-const input = {
-  ["\u00C9cole"]: 1,
-  ["\u00F6lwert"]: 2,
-  ["\u65E5\u672C\u8A9E"]: 3,
-  ["key_\u00D6lig"]: 4,
-  ["\u00D6"]: 5,
-  ["\u0130stanbul"]: 6,
-  ["\u00DF"]: 7,
-  ["\uD801\uDC28test"]: 8,
-  ["\u0391\u03A3_\u0391\u03A3"]: 9,
-  ["e\u0301cole"]: 10,
-  ["\u00FCber_Stra\u00DFe"]: 11,
-  ["MAX_COUNT"]: 12,
-  ["fooBar"]: 13,
-};
-
-// Expectations are JavaScript's own case semantics, not a snapshot of the Go
-// emit: full case conversion (ß -> SS, İ -> i + U+0307, word-final
-// sigma ΑΣ -> ας) and UTF-16 code-unit indexing, under which
-// str[0] of an astral character is an uncased lone surrogate and stays put.
-const expected = {
-  camel: {
-    ["\u00E9cole"]: 1,
-    ["\u00F6lwert"]: 2,
-    ["\u65E5\u672C\u8A9E"]: 3,
-    ["key\u00D6lig"]: 4,
-    ["\u00F6"]: 5,
-    ["i\u0307stanbul"]: 6,
-    ["\u00DF"]: 7,
-    ["\uD801\uDC28test"]: 8,
-    ["\u03B1\u03C2\u0391\u03C3"]: 9,
-    ["e\u0301cole"]: 10,
-    ["\u00FCberStra\u00DFe"]: 11,
-    ["maxCount"]: 12,
-    ["fooBar"]: 13,
-  },
-  pascal: {
-    ["\u00C9cole"]: 1,
-    ["\u00D6lwert"]: 2,
-    ["\u65E5\u672C\u8A9E"]: 3,
-    ["Key\u00D6lig"]: 4,
-    ["\u00D6"]: 5,
-    ["\u0130stanbul"]: 6,
-    ["SS"]: 7,
-    ["\uD801\uDC28test"]: 8,
-    ["\u0391\u03C3\u0391\u03C3"]: 9,
-    ["E\u0301cole"]: 10,
-    ["\u00DCberStra\u00DFe"]: 11,
-    ["MaxCount"]: 12,
-    ["FooBar"]: 13,
-  },
-  snake: {
-    ["\u00E9cole"]: 1,
-    ["\u00F6lwert"]: 2,
-    ["\u65E5\u672C\u8A9E"]: 3,
-    ["key_\u00F6lig"]: 4,
-    ["\u00F6"]: 5,
-    ["i\u0307stanbul"]: 6,
-    ["\u00DF"]: 7,
-    ["\uD801\uDC28test"]: 8,
-    ["\u03B1\u03C2_\u03B1\u03C2"]: 9,
-    ["e\u0301cole"]: 10,
-    ["\u00FCber_stra\u00DFe"]: 11,
-    ["max_count"]: 12,
-    ["foo_bar"]: 13,
-  },
-  kebab: {
-    ["\u00E9cole"]: 1,
-    ["\u00F6lwert"]: 2,
-    ["\u65E5\u672C\u8A9E"]: 3,
-    ["key-\u00F6lig"]: 4,
-    ["\u00F6"]: 5,
-    ["i\u0307stanbul"]: 6,
-    ["\u00DF"]: 7,
-    ["\uD801\uDC28test"]: 8,
-    ["\u03B1\u03C2-\u03B1\u03C2"]: 9,
-    ["e\u0301cole"]: 10,
-    ["\u00FCber-stra\u00DFe"]: 11,
-    ["max-count"]: 12,
-    ["foo-bar"]: 13,
-  },
-};
-
-const normalize = (object) =>
-  JSON.stringify(
-    Object.entries(object)
-      .map(([key, value]) => [Array.from(key, (c) => c.charCodeAt(0)), value])
-      .sort((a, b) => (String(a) < String(b) ? -1 : 1)),
-  );
-
-const notations = ["camel", "pascal", "snake", "kebab"];
-const capitalize = (name) => name[0].toUpperCase() + name.substring(1);
-
-for (const notation of notations) {
-  const want = normalize(expected[notation]);
-
-  // The statically emitted converter: one property assignment per known key.
-  const staticResult = mod["to" + capitalize(notation)](input);
-  if (normalize(staticResult) !== want) {
-    throw new Error(
-      "static " + notation + " emit disagreed with JavaScript case semantics:\n" +
-        "  expected " + want + "\n" +
-        "  actual   " + normalize(staticResult),
-    );
-  }
-
-  // The dynamic converter: one runtime _notation* call per index-signature key.
-  const dynamicResult = mod["to" + capitalize(notation) + "Dynamic"](input);
-  if (normalize(dynamicResult) !== normalize(staticResult)) {
-    throw new Error(
-      "static " + notation + " emit disagreed with the runtime helper:\n" +
-        "  runtime " + normalize(dynamicResult) + "\n" +
-        "  emit    " + normalize(staticResult),
-    );
-  }
-
-  for (const key of Object.keys(staticResult)) {
-    if (key.includes("�")) {
-      throw new Error(
-        "renamed " + notation + " key contains U+FFFD: " + JSON.stringify(key),
-      );
-    }
-  }
-}
-`