typia 13.1.1 → 13.1.19

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

@@ -0,0 +1,227 @@
+package main
+
+import (
+  "os"
+  "os/exec"
+  "path/filepath"
+  "testing"
+)
+
+// TestTupleOptionalCompareCloneTransform pins optional-trailing tuple semantics
+// across is / compare.equals / plain.clone / plain.classify.
+//
+// Issue #2202: for a tuple with an omitted optional trailing element, `is`
+// correctly validates with a length range (`1 <= length && 2 >= length`), but
+// `compare.equals` emitted a hard `x.length === 2` gate and `plain.clone` /
+// `plain.classify` materialized the absent element as a phantom `undefined`
+// (`[input[0], input[1]]`). So `equals(["a"], ["a"])` was false (reflexivity
+// broken; disagrees with `is`) and `clone(["a"])` was `["a", undefined]`
+// (length 2), not deep-equal to its input. The three must honor the same
+// optional-trailing semantics as `is`.
+//
+//  1. Transform is / equals / clone / classify over `[string, number?]` and
+//     `[string, number?, boolean?]`, plus fully-required and rest controls.
+//  2. Require equals reflexive over omitted-optional values, clone/classify to
+//     produce the correct length with no phantom slot, and `equals(x, clone(x))`
+//     to hold for every is-valid x.
+//  3. Require fully-populated tuples and rest tuples to be unchanged.
+func TestTupleOptionalCompareCloneTransform(t *testing.T) {
+  project := tupleOptionalCompareCloneProject(t)
+  out, errText, code := ttscTypiaTestCapture(func() int {
+    return runTransform([]string{
+      "--cwd", project,
+      "--tsconfig", "tsconfig.json",
+      "--file", "src/main.ts",
+      "--output", "js",
+    })
+  })
+  if code != 0 {
+    t.Fatalf("tuple optional compare/clone transform failed: code=%d stderr=\n%s", code, errText)
+  }
+  tupleOptionalCompareCloneRunRuntimeCases(t, project, out)
+}
+
+func tupleOptionalCompareCloneProject(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, "tuple-optional-")
+  if err != nil {
+    t.Fatalf("create temp fixture: %v", err)
+  }
+  t.Cleanup(func() {
+    _ = os.RemoveAll(dir)
+  })
+  src := filepath.Join(dir, "src")
+  if err := os.MkdirAll(src, 0o755); err != nil {
+    t.Fatalf("mkdir fixture src: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(dir, "tsconfig.json"), []byte(tupleOptionalCompareCloneTSConfig), 0o644); err != nil {
+    t.Fatalf("write tsconfig: %v", err)
+  }
+  if err := os.WriteFile(filepath.Join(src, "main.ts"), []byte(tupleOptionalCompareCloneSource), 0o644); err != nil {
+    t.Fatalf("write source: %v", err)
+  }
+  return dir
+}
+
+func tupleOptionalCompareCloneRunRuntimeCases(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(tupleOptionalCompareCloneRuntimeRunner), 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("tuple optional compare/clone runtime cases failed: %v\n%s", err, output)
+  }
+}
+
+const tupleOptionalCompareCloneTSConfig = `{
+  "compilerOptions": {
+    "target": "ES2022",
+    "module": "commonjs",
+    "moduleResolution": "bundler",
+    "ignoreDeprecations": "6.0",
+    "types": ["*"],
+    "esModuleInterop": true,
+    "strict": true,
+    "skipLibCheck": true
+  },
+  "include": ["src"]
+}
+`
+
+const tupleOptionalCompareCloneSource = `import typia from "typia";
+
+export const isPair = typia.createIs<[string, number?]>();
+export const equalsPair = typia.compare.createEquals<[string, number?]>();
+export const clonePair = typia.plain.createClone<[string, number?]>();
+export const classifyPair = typia.plain.createClassify<[string, number?]>();
+
+export const isTriple = typia.createIs<[string, number?, boolean?]>();
+export const equalsTriple = typia.compare.createEquals<[string, number?, boolean?]>();
+export const cloneTriple = typia.plain.createClone<[string, number?, boolean?]>();
+export const classifyTriple = typia.plain.createClassify<[string, number?, boolean?]>();
+
+// boundary: a tuple whose only element is optional.
+export const equalsSolo = typia.compare.createEquals<[number?]>();
+export const cloneSolo = typia.plain.createClone<[number?]>();
+
+// boundary: an optional trailing element that is itself a nested tuple.
+export const equalsNested = typia.compare.createEquals<[string, [number, boolean]?]>();
+export const cloneNested = typia.plain.createClone<[string, [number, boolean]?]>();
+
+// control: a fully-required tuple must stay byte-identical.
+export const equalsFixed = typia.compare.createEquals<[string, number]>();
+export const cloneFixed = typia.plain.createClone<[string, number]>();
+
+// control: a rest tuple must stay byte-identical.
+export const equalsRest = typia.compare.createEquals<[string, ...number[]]>();
+export const cloneRest = typia.plain.createClone<[string, ...number[]]>();
+`
+
+const tupleOptionalCompareCloneRuntimeRunner = `const mod = require("./main.cjs");
+
+const expect = (label, actual, expected) => {
+  if (actual !== expected) {
+    throw new Error(label + ": expected " + expected + ", got " + actual);
+  }
+};
+
+// A clone must be a distinct array, deep-equal to expected, with no phantom
+// trailing slot (length matches, and the first out-of-range index is absent).
+const expectClone = (label, result, expected) => {
+  if (!Array.isArray(result)) throw new Error(label + ": not an array");
+  if (result.length !== expected.length)
+    throw new Error(label + ": length " + result.length + " !== " + expected.length);
+  if (expected.length in result)
+    throw new Error(label + ": phantom slot at index " + expected.length);
+  for (let i = 0; i < expected.length; ++i)
+    if (result[i] !== expected[i])
+      throw new Error(label + ": [" + i + "] " + result[i] + " !== " + expected[i]);
+};
+
+// --- is: the reference range semantics (unchanged) ---
+expect("is pair omitted", mod.isPair(["a"]), true);
+expect("is pair present", mod.isPair(["a", 1]), true);
+expect("is pair too long", mod.isPair(["a", 1, 2]), false);
+expect("is triple omitted", mod.isTriple(["a"]), true);
+
+// --- equals: reflexive over omitted optional; matches is ---
+expect("equals pair omitted reflexive", mod.equalsPair(["a"], ["a"]), true);
+expect("equals pair omitted vs present", mod.equalsPair(["a"], ["a", 1]), false);
+expect("equals pair present reflexive", mod.equalsPair(["a", 1], ["a", 1]), true);
+expect("equals pair present differ", mod.equalsPair(["a", 1], ["a", 2]), false);
+expect("equals triple omitted reflexive", mod.equalsTriple(["a"], ["a"]), true);
+expect("equals triple mid present reflexive", mod.equalsTriple(["a", 1], ["a", 1]), true);
+expect("equals triple full reflexive", mod.equalsTriple(["a", 1, true], ["a", 1, true]), true);
+expect("equals triple omitted vs present", mod.equalsTriple(["a"], ["a", 1]), false);
+
+// --- clone: correct length, no phantom undefined ---
+expectClone("clone pair omitted", mod.clonePair(["a"]), ["a"]);
+expectClone("clone pair present", mod.clonePair(["a", 1]), ["a", 1]);
+expectClone("clone triple omitted", mod.cloneTriple(["a"]), ["a"]);
+expectClone("clone triple mid present", mod.cloneTriple(["a", 1]), ["a", 1]);
+expectClone("clone triple full", mod.cloneTriple(["a", 1, true]), ["a", 1, true]);
+
+// --- classify: same tuple-inline path as clone ---
+expectClone("classify pair omitted", mod.classifyPair(["a"]), ["a"]);
+expectClone("classify triple omitted", mod.classifyTriple(["a"]), ["a"]);
+
+// --- equals(x, clone(x)) holds for every is-valid x ---
+for (const x of [["a"], ["a", 1]]) {
+  if (mod.isPair(x)) expect("equals pair (x, clone x) " + JSON.stringify(x), mod.equalsPair(x, mod.clonePair(x)), true);
+}
+for (const x of [["a"], ["a", 1], ["a", 1, true]]) {
+  if (mod.isTriple(x)) expect("equals triple (x, clone x) " + JSON.stringify(x), mod.equalsTriple(x, mod.cloneTriple(x)), true);
+}
+
+// --- boundary: only-optional tuple ---
+expect("equals solo empty reflexive", mod.equalsSolo([], []), true);
+expect("equals solo empty vs present", mod.equalsSolo([], [1]), false);
+expect("equals solo present reflexive", mod.equalsSolo([1], [1]), true);
+expectClone("clone solo empty", mod.cloneSolo([]), []);
+expectClone("clone solo present", mod.cloneSolo([1]), [1]);
+
+// --- boundary: nested tuple as the optional trailing element ---
+expect("equals nested omitted reflexive", mod.equalsNested(["a"], ["a"]), true);
+expect("equals nested present reflexive", mod.equalsNested(["a", [1, true]], ["a", [1, true]]), true);
+expect("equals nested omitted vs present", mod.equalsNested(["a"], ["a", [1, true]]), false);
+expectClone("clone nested omitted", mod.cloneNested(["a"]), ["a"]);
+{
+  const nested = mod.cloneNested(["a", [1, true]]);
+  if (nested.length !== 2) throw new Error("clone nested present: outer length " + nested.length);
+  if (1 in nested === false) throw new Error("clone nested present: missing inner tuple");
+  expectClone("clone nested inner", nested[1], [1, true]);
+}
+
+// --- controls: fully-required and rest tuples unchanged ---
+expect("equals fixed reflexive", mod.equalsFixed(["a", 1], ["a", 1]), true);
+expect("equals fixed differ", mod.equalsFixed(["a", 1], ["a", 2]), false);
+expectClone("clone fixed", mod.cloneFixed(["a", 1]), ["a", 1]);
+
+expect("equals rest solo", mod.equalsRest(["a"], ["a"]), true);
+expect("equals rest multi", mod.equalsRest(["a", 1, 2], ["a", 1, 2]), true);
+expect("equals rest length differ", mod.equalsRest(["a", 1], ["a", 1, 2]), false);
+expectClone("clone rest solo", mod.cloneRest(["a"]), ["a"]);
+expectClone("clone rest multi", mod.cloneRest(["a", 1, 2]), ["a", 1, 2]);
+`

package/native/core/factories/FormatCheatSheet.go

@@ -4,8 +4,41 @@ func formatCheatSheet_RegexCall(text string) string {
   return text + ".test($input)"
 }
 
+// formatCheatSheet_ALIASES maps an alternative `@format` spelling onto the
+// canonical FormatCheatSheet key it means.
+//
+// An alias owns no validator. It resolves to the cheat sheet entry through
+// formatCheatSheet_resolve, so FormatCheatSheet stays the single owner of every
+// format's validator and a correction to one reaches every spelling of it. The
+// aliases previously carried validator strings of their own, which made each of
+// them a second implementation sharing a name and free to drift: `datetime`
+// emitted `format: "date-time"` while validating with `new Date`, so it accepted
+// February 30th and rejected the RFC 3339 leap second the cheat sheet handles.
+//
+// Aliases live beside the cheat sheet so that enumerating this file enumerates
+// every owner of the `@format` contract.
+var formatCheatSheet_ALIASES = map[string]string{
+  "datetime": "date-time",
+  "dateTime": "date-time",
+}
+
+// formatCheatSheet_resolve resolves a written `@format` value to the canonical
+// format name and the validator FormatCheatSheet owns for it, reporting whether
+// the value names a supported format at all.
+func formatCheatSheet_resolve(value string) (string, string, bool) {
+  name := value
+  if canonical, ok := formatCheatSheet_ALIASES[value]; ok {
+    name = canonical
+  }
+  validate, ok := FormatCheatSheet[name]
+  if ok == false {
+    return "", "", false
+  }
+  return name, validate, true
+}
+
 var FormatCheatSheet = map[string]string{
-  "byte":                  "/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/gm.test($input)",
+  "byte":                  `/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/.test($input)`,
   "password":              "true",
   "regex":                 "(() => { try { new RegExp($input); return true; } catch { return false; } })()",
   "uuid":                  "/^(?:urn:uuid:)?[0-9a-f]{8}-(?:[0-9a-f]{4}-){3}[0-9a-f]{12}$/i.test($input)",
@@ -13,16 +46,16 @@ var FormatCheatSheet = map[string]string{
   "hostname":              "/^(?=.{1,253}\\.?$)[a-z0-9](?:[a-z0-9-]{0,61}[a-z0-9])?(?:\\.[a-z0-9](?:[-0-9a-z]{0,61}[0-9a-z])?)*\\.?$/i.test($input)",
   "idn-email":             "/^(([^<>()[\\]\\.,;:\\s@\\\"]+(\\.[^<>()[\\]\\.,;:\\s@\\\"]+)*)|(\\\".+\\\"))@(([^<>()[\\]\\.,;:\\s@\\\"]+\\.)+[^<>()[\\]\\.,;:\\s@\\\"]{2,})$/i.test($input)",
   "idn-hostname":          "/^([a-z0-9\\u00a1-\\uffff0-9]+(-[a-z0-9\\u00a1-\\uffff0-9]+)*\\.)+[a-z\\u00a1-\\uffff]{2,}$/i.test($input)",
-  "iri":                   "/^[A-Za-z][\\d+-.A-Za-z]*:[^\\u0000-\\u0020\"<>\\\\^`{|}]*$/u.test($input)",
-  "iri-reference":         "/^[A-Za-z][\\d+-.A-Za-z]*:[^\\u0000-\\u0020\"<>\\\\^`{|}]*$/u.test($input)",
+  "iri":                   `(() => !/[\u0000-\u0020\u007f-\u009f\ud800-\udfff"<>\\^\x60{|}]/u.test($input) && !/%(?![0-9A-Fa-f]{2})/u.test($input) && /^[A-Za-z][A-Za-z0-9+.-]*:/u.test($input))()`,
+  "iri-reference":         `(() => { if (/[\u0000-\u0020\u007f-\u009f\ud800-\udfff"<>\\^\x60{|}]/u.test($input) || /%(?![0-9A-Fa-f]{2})/u.test($input)) return false; const colon = $input.indexOf(":"); const boundary = $input.search(/[/?#]/u); return colon === -1 || (boundary !== -1 && boundary < colon) || /^[A-Za-z][A-Za-z0-9+.-]*:/u.test($input); })()`,
   "ipv4":                  "/^(?:(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)\\.){3}(?:25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)$/.test($input)",
-  "ipv6":                  "/^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-9]?d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-9]?d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-9]?d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-9]?d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-9]?d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-9]?d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]d|1dd|[1-9]?d)(.(25[0-5]|2[0-4]d|1dd|[1-9]?d)){3}))|:)))$/i.test($input)",
+  "ipv6":                  `/^((([0-9a-f]{1,4}:){7}([0-9a-f]{1,4}|:))|(([0-9a-f]{1,4}:){6}(:[0-9a-f]{1,4}|((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){5}(((:[0-9a-f]{1,4}){1,2})|:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3})|:))|(([0-9a-f]{1,4}:){4}(((:[0-9a-f]{1,4}){1,3})|((:[0-9a-f]{1,4})?:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){3}(((:[0-9a-f]{1,4}){1,4})|((:[0-9a-f]{1,4}){0,2}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){2}(((:[0-9a-f]{1,4}){1,5})|((:[0-9a-f]{1,4}){0,3}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(([0-9a-f]{1,4}:){1}(((:[0-9a-f]{1,4}){1,6})|((:[0-9a-f]{1,4}){0,4}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:))|(:(((:[0-9a-f]{1,4}){1,7})|((:[0-9a-f]{1,4}){0,5}:((25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}))|:)))$/i.test($input)`,
   "uri":                   "/\\/|:/.test($input) && /^(?:[a-z][a-z0-9+\\-.]*:)(?:\\/?\\/(?:(?:[a-z0-9\\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\\.[a-z0-9\\-._~!$&'()*+,;=:]+)\\]|(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)|(?:[a-z0-9\\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\\d*)?(?:\\/(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\\/(?:(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\\/(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\\/(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\\?(?:[a-z0-9\\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i.test($input)",
-  "uri-reference":         "/^(?:[a-z][a-z0-9+\\-.]*:)?(?:\\/?\\/(?:(?:[a-z0-9\\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\\.[a-z0-9\\-._~!$&'()*+,;=:]+)\\]|(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)|(?:[a-z0-9\\-._~!$&'\"()*+,;=]|%[0-9a-f]{2})*)(?::\\d*)?(?:\\/(?:[a-z0-9\\-._~!$&'\"()*+,;=:@]|%[0-9a-f]{2})*)*|\\/(?:(?:[a-z0-9\\-._~!$&'\"()*+,;=:@]|%[0-9a-f]{2})+(?:\\/(?:[a-z0-9\\-._~!$&'\"()*+,;=:@]|%[0-9a-f]{2})*)*)?|(?:[a-z0-9\\-._~!$&'\"()*+,;=:@]|%[0-9a-f]{2})+(?:\\/(?:[a-z0-9\\-._~!$&'\"()*+,;=:@]|%[0-9a-f]{2})*)*)?(?:\\?(?:[a-z0-9\\-._~!$&'\"()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\\-._~!$&'\"()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i.test($input)",
+  "uri-reference":         "/^(?:(?:[a-z][a-z0-9+\\-.]*:)?(?:\\/?\\/(?:(?:[a-z0-9\\-._~!$&'()*+,;=:]|%[0-9a-f]{2})*@)?(?:\\[(?:(?:(?:(?:[0-9a-f]{1,4}:){6}|::(?:[0-9a-f]{1,4}:){5}|(?:[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){4}|(?:(?:[0-9a-f]{1,4}:){0,1}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){3}|(?:(?:[0-9a-f]{1,4}:){0,2}[0-9a-f]{1,4})?::(?:[0-9a-f]{1,4}:){2}|(?:(?:[0-9a-f]{1,4}:){0,3}[0-9a-f]{1,4})?::[0-9a-f]{1,4}:|(?:(?:[0-9a-f]{1,4}:){0,4}[0-9a-f]{1,4})?::)(?:[0-9a-f]{1,4}:[0-9a-f]{1,4}|(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?))|(?:(?:[0-9a-f]{1,4}:){0,5}[0-9a-f]{1,4})?::[0-9a-f]{1,4}|(?:(?:[0-9a-f]{1,4}:){0,6}[0-9a-f]{1,4})?::)|[Vv][0-9a-f]+\\.[a-z0-9\\-._~!$&'()*+,;=:]+)\\]|(?:(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)\\.){3}(?:25[0-5]|2[0-4]\\d|[01]?\\d\\d?)|(?:[a-z0-9\\-._~!$&'()*+,;=]|%[0-9a-f]{2})*)(?::\\d*)?(?:\\/(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|\\/(?:(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\\/(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)?)?|(?:[a-z][a-z0-9+\\-.]*:)(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})+(?:\\/(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*|(?:[a-z0-9\\-._~!$&'()*+,;=@]|%[0-9a-f]{2})+(?:\\/(?:[a-z0-9\\-._~!$&'()*+,;=:@]|%[0-9a-f]{2})*)*)(?:\\?(?:[a-z0-9\\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?(?:#(?:[a-z0-9\\-._~!$&'()*+,;=:@/?]|%[0-9a-f]{2})*)?$/i.test($input)",
   "uri-template":          "/^(?:(?:[^\\x00-\\x20\"'<>%\\\\^`{|}]|%[0-9a-f]{2})|\\{[+#./;?&=,!@|]?(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\\*)?(?:,(?:[a-z0-9_]|%[0-9a-f]{2})+(?::[1-9][0-9]{0,3}|\\*)?)*\\})*$/i.test($input)",
   "url":                   "/^(?:https?|ftp):\\/\\/(?:[^\\s/?#@]+(?::[^\\s/?#@]*)?@)?(?:(?!(?:10|127)(?:\\.\\d{1,3}){3})(?!(?:169\\.254|192\\.168)(?:\\.\\d{1,3}){2})(?!172\\.(?:1[6-9]|2\\d|3[0-1])(?:\\.\\d{1,3}){2})(?:[1-9]\\d?|1\\d\\d|2[01]\\d|22[0-3])(?:\\.(?:1?\\d{1,2}|2[0-4]\\d|25[0-5])){2}(?:\\.(?:[1-9]\\d?|1\\d\\d|2[0-4]\\d|25[0-4]))|(?=.{1,253}(?::\\d{2,5})?(?:\\/[^\\s]*)?$)(?:[a-z0-9\\u00a1-\\uffff](?:[-a-z0-9\\u00a1-\\uffff]{0,61}[a-z0-9\\u00a1-\\uffff])?\\.)+(?:[a-z\\u00a1-\\uffff](?:[-a-z0-9\\u00a1-\\uffff]{0,61}[a-z0-9\\u00a1-\\uffff])))(?::\\d{2,5})?(?:\\/[^\\s]*)?$/iu.test($input)",
-  "date-time":             "/^[0-9]{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])(T|\\s)([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9](?:\\.[0-9]{1,9})?(Z|[+-]([01][0-9]|2[0-3]):[0-5][0-9])$/i.test($input)",
-  "date":                  "/^[0-9]{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$/.test($input)",
+  "date-time":             `(() => { const match = /^([0-9]{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])[Tt]((?:[01][0-9]|2[0-3])):([0-5][0-9]):([0-5][0-9]|60)(?:\.[0-9]+)?(?:[Zz]|([+-])((?:[01][0-9]|2[0-3])):([0-5][0-9]))$/.exec($input); if (match === null) return false; const year = Number(match[1]); const month = Number(match[2]); const day = Number(match[3]); if (day > [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month - 1] + (month === 2 && (year % 400 === 0 || (year % 4 === 0 && year % 100 !== 0)) ? 1 : 0)) return false; if (match[6] !== "60") return true; const instant = new Date(0); instant.setUTCFullYear(year, month - 1, day); instant.setUTCHours(Number(match[4]), Number(match[5]), 0, 0); const offset = match[7] === undefined ? 0 : (match[7] === "+" ? 1 : -1) * (Number(match[8]) * 60 + Number(match[9])); instant.setUTCMinutes(instant.getUTCMinutes() - offset); return instant.getUTCHours() === 23 && instant.getUTCMinutes() === 59 && ((instant.getUTCMonth() === 5 && instant.getUTCDate() === 30) || (instant.getUTCMonth() === 11 && instant.getUTCDate() === 31)); })()`,
+  "date":                  `(() => { const match = /^([0-9]{4})-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$/.exec($input); if (match === null) return false; const year = Number(match[1]); const month = Number(match[2]); const day = Number(match[3]); return day <= [31, 28, 31, 30, 31, 30, 31, 31, 30, 31, 30, 31][month - 1] + (month === 2 && (year % 400 === 0 || (year % 4 === 0 && year % 100 !== 0)) ? 1 : 0); })()`,
   "time":                  "/^([01][0-9]|2[0-3]):[0-5][0-9]:[0-5][0-9](?:\\.[0-9]{1,9})?(Z|[+-]([01][0-9]|2[0-3]):[0-5][0-9])$/i.test($input)",
   "duration":              "/^P(?!$)((\\d+Y)?(\\d+M)?(\\d+D)?(T(?=\\d)(\\d+H)?(\\d+M)?(\\d+S)?)?|(\\d+W)?)$/.test($input)",
   "json-pointer":          "/^(?:\\/(?:[^~/]|~0|~1)*)*$/.test($input)",

package/native/core/factories/IdentifierFactory.go

@@ -1,8 +1,9 @@
 package factories
 
 import (
-  "strconv"
+  "fmt"
   "strings"
+  "unicode/utf8"
 
   shimast "github.com/microsoft/typescript-go/shim/ast"
   shimprinter "github.com/microsoft/typescript-go/shim/printer"
@@ -71,12 +72,138 @@ func (identifierFactoryNamespace) GetName(input *shimast.Expression) string {
   return "unknown"
 }
 
+// Postfix renders the accessor for `str` as JavaScript source for a string
+// literal, because callers splice the result straight into emitted text (see
+// AssertProgrammer and ValidateProgrammer building `_path + <postfix>`).
+//
+// The value of that literal must equal what the runtime helper
+// `typia/lib/internal/_accessExpressionAsString` computes for the same key,
+// since dynamic keys take that runtime path while sole-literal keys are folded
+// here at compile time. Both must produce one path grammar, which
+// `typia/lib/internal/_createStandardSchema` parses back with JSON.parse.
+//
+// So there are two nested levels, and they escape for different readers. The
+// key becomes JSON text, which is part of the path a user sees and JSON.parse
+// reads. That text is then embedded in JavaScript source. Escaping only one
+// level emits a file that does not parse; escaping both for the same reader
+// makes the reported path disagree with the runtime helper.
 func (identifierFactoryNamespace) Postfix(str string) string {
   if identifierFactory_variable(str) {
-    return "\"." + str + "\""
+    return identifierFactory_source("." + str)
   }
-  quoted := strings.ReplaceAll(strconv.Quote(str), "\"", "\\\"")
-  return "\"[" + quoted + "]\""
+  return identifierFactory_source("[" + identifierFactory_json(str) + "]")
+}
+
+// identifierFactory_json renders `str` as JSON text, matching JSON.stringify so
+// that the path this lands in is the one _accessExpressionAsString builds for
+// the same key at runtime, and so JSON.parse in _createStandardSchema reads the
+// key back out.
+func identifierFactory_json(str string) string {
+  return identifierFactory_quote(str, false)
+}
+
+// identifierFactory_source renders `str` as JavaScript source for a string
+// literal whose value is exactly `str`.
+//
+// This is JSON's escape set plus the line separators. JSON string syntax is
+// otherwise a subset of JavaScript's: both forbid a raw `"` and `\`, and JSON
+// already escapes every character below U+0020, which covers the CR and LF that
+// JavaScript also forbids raw. U+2028 and U+2029 are the whole difference, being
+// line terminators to JavaScript but ordinary characters to JSON.
+func identifierFactory_source(str string) string {
+  return identifierFactory_quote(str, true)
+}
+
+// identifierFactory_quote writes a quoted literal, escaping the line separators
+// only when the reader is a JavaScript parser.
+//
+// strconv.Quote cannot serve either role: it escapes for Go, and Go and
+// JavaScript disagree. Quote renders U+0007 as `\a` and a non-printable astral
+// rune as `\U0001d173`; JavaScript has neither escape and decodes them as the
+// identity escapes `a` and `U`, silently corrupting the key, while JSON.parse
+// rejects both outright.
+func identifierFactory_quote(str string, source bool) string {
+  var builder strings.Builder
+  builder.Grow(len(str) + 2)
+  builder.WriteByte('"')
+  for i := 0; i < len(str); {
+    if char := str[i]; char < utf8.RuneSelf {
+      i++
+      switch char {
+      case '"':
+        builder.WriteString("\\\"")
+      case '\\':
+        builder.WriteString("\\\\")
+      case '\b':
+        builder.WriteString("\\b")
+      case '\f':
+        builder.WriteString("\\f")
+      case '\n':
+        builder.WriteString("\\n")
+      case '\r':
+        builder.WriteString("\\r")
+      case '\t':
+        builder.WriteString("\\t")
+      default:
+        // JSON forbids a raw control character in a string, and JSON.parse
+        // throws on one rather than reporting the validation issue that the
+        // path belongs to. Every other ASCII byte is safe verbatim.
+        if char < 0x20 {
+          builder.WriteString(identifierFactory_unicode_escape(rune(char)))
+        } else {
+          builder.WriteByte(char)
+        }
+      }
+      continue
+    }
+    if unit, size := identifierFactory_surrogate(str[i:]); size != 0 {
+      // A lone surrogate reaches here WTF-8 encoded and has no valid UTF-8
+      // form, so it survives only as an escape. JSON.stringify does the same.
+      builder.WriteString(identifierFactory_unicode_escape(unit))
+      i += size
+      continue
+    }
+    rune_, size := utf8.DecodeRuneInString(str[i:])
+    if rune_ == utf8.RuneError && size == 1 {
+      // Not UTF-8 at all. No escape can denote the byte, so spend the
+      // replacement character and keep the literal well-formed; the
+      // alternative is emitting a file that does not parse.
+      builder.WriteString(identifierFactory_unicode_escape(utf8.RuneError))
+      i++
+      continue
+    }
+    if source && (rune_ == '\u2028' || rune_ == '\u2029') {
+      // A line terminator to JavaScript, so a raw one would end the literal on
+      // a target below ES2019. Escaping it in the source is invisible to the
+      // reader of the path, because JavaScript decodes it straight back.
+      builder.WriteString(identifierFactory_unicode_escape(rune_))
+      i += size
+      continue
+    }
+    builder.WriteString(str[i : i+size])
+    i += size
+  }
+  builder.WriteByte('"')
+  return builder.String()
+}
+
+// identifierFactory_unicode_escape writes the `\uXXXX` form, which denotes one
+// UTF-16 code unit and so only spans the Basic Multilingual Plane. Every caller
+// passes a control character, a surrogate, or the replacement character; an
+// astral rune needs no escape and must keep taking the verbatim path, because
+// four hex digits cannot spell it.
+func identifierFactory_unicode_escape(value rune) string {
+  return fmt.Sprintf("\\u%04x", value)
+}
+
+// identifierFactory_surrogate decodes a leading WTF-8 encoded surrogate code
+// unit, which utf8.DecodeRuneInString reports as an error because no valid
+// UTF-8 sequence denotes one.
+func identifierFactory_surrogate(str string) (rune, int) {
+  if len(str) < 3 || str[0] != 0xed || str[1] < 0xa0 || str[1] > 0xbf || str[2] < 0x80 || str[2] > 0xbf {
+    return 0, 0
+  }
+  return rune(str[0]&0x0f)<<12 | rune(str[1]&0x3f)<<6 | rune(str[2]&0x3f), 3
 }
 
 func (identifierFactoryNamespace) Parameter(name any, typeNode *shimast.TypeNode, init *shimast.Node, emit ...*shimprinter.EmitContext) *shimast.Node {