typia 15.2.1 → 15.2.2

package/lib/internal/_stringLengthGte.d.ts

@@ -1,12 +1,16 @@
 /**
  * Test whether a string has at least the given number of code points.
  *
- * Iteration stops as soon as the count is reached, so a long string is not
- * scanned to its end.
+ * Twice the requested minimum in UTF-16 units guarantees enough code points.
+ * Other inputs are counted only until the minimum is reached.
  *
- * @evidence contracts/common.md#principled-implementation The iterator is consumed only until the count reaches the requested minimum, which decides the lower bound without scanning the whole string; a minimum of zero is true at once.
+ * @evidence contracts/common.md#principled-implementation Each code point occupies at most two UTF-16 units, so code-unit length at least twice the minimum proves the code-point bound. Otherwise iteration stops at the minimum; nonpositive minima remain true and NaN remains false.
  * @evidence contracts/common.md#clear-and-simple-design One loop with an early return.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts The unit is code points.
  * @evidence contracts/common.md#meaningful-documentation The doc states the early return and the code point unit.
+ * @evidence contracts/performance.md#efficient-algorithms The code-unit lower bound accepts in constant time without allocating an iterator; ambiguous inputs retain the bounded code-point walk and constant auxiliary space.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each call depends on its own primitive string and bound; this predicate coordinates no repeated requests or shared computation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate retains no state or handles after returning; iteration and scalar counters are call-local.
  */
 export declare const _stringLengthGte: (value: string, length: number) => boolean;

package/lib/internal/_stringLengthGte.js

@@ -4,15 +4,21 @@ exports._stringLengthGte = void 0;
 /**
  * Test whether a string has at least the given number of code points.
  *
- * Iteration stops as soon as the count is reached, so a long string is not
- * scanned to its end.
+ * Twice the requested minimum in UTF-16 units guarantees enough code points.
+ * Other inputs are counted only until the minimum is reached.
  *
- * @evidence contracts/common.md#principled-implementation The iterator is consumed only until the count reaches the requested minimum, which decides the lower bound without scanning the whole string; a minimum of zero is true at once.
+ * @evidence contracts/common.md#principled-implementation Each code point occupies at most two UTF-16 units, so code-unit length at least twice the minimum proves the code-point bound. Otherwise iteration stops at the minimum; nonpositive minima remain true and NaN remains false.
  * @evidence contracts/common.md#clear-and-simple-design One loop with an early return.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts The unit is code points.
  * @evidence contracts/common.md#meaningful-documentation The doc states the early return and the code point unit.
+ * @evidence contracts/performance.md#efficient-algorithms The code-unit lower bound accepts in constant time without allocating an iterator; ambiguous inputs retain the bounded code-point walk and constant auxiliary space.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each call depends on its own primitive string and bound; this predicate coordinates no repeated requests or shared computation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate retains no state or handles after returning; iteration and scalar counters are call-local.
  */
 const _stringLengthGte = (value, length) => {
+    if (value.length >= length * 2)
+        return true;
     let count = 0;
     if (length <= count)
         return true;

package/lib/internal/_stringLengthGte.js.map

@@ -1 +1 @@
-{"version":3,"file":"_stringLengthGte.js","sources":["../../src/internal/_stringLengthGte.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;GAUG;AACI,MAAM,gBAAgB,GAAG,CAAC,KAAa,EAAE,MAAc,EAAW,EAAE;IACzE,IAAI,KAAK,GAAW,CAAC,CAAC;IACtB,IAAI,MAAM,IAAI,KAAK;QAAE,OAAO,IAAI,CAAC;IACjC,KAAK,MAAM,GAAG,IAAI,KAAK;QAAE,IAAI,MAAM,IAAI,EAAE,KAAK;YAAE,OAAO,IAAI,CAAC;IAC5D,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AALW,QAAA,gBAAgB,GAAhB,gBAAgB,CAK3B"}
+{"version":3,"file":"_stringLengthGte.js","sources":["../../src/internal/_stringLengthGte.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;GAcG;AACI,MAAM,gBAAgB,GAAG,CAAC,KAAa,EAAE,MAAc,EAAW,EAAE;IACzE,IAAI,KAAK,CAAC,MAAM,IAAI,MAAM,GAAG,CAAC;QAAE,OAAO,IAAI,CAAC;IAC5C,IAAI,KAAK,GAAW,CAAC,CAAC;IACtB,IAAI,MAAM,IAAI,KAAK;QAAE,OAAO,IAAI,CAAC;IACjC,KAAK,MAAM,GAAG,IAAI,KAAK;QAAE,IAAI,MAAM,IAAI,EAAE,KAAK;YAAE,OAAO,IAAI,CAAC;IAC5D,OAAO,KAAK,CAAC;AACf,CAAC,CAAC;AANW,QAAA,gBAAgB,GAAhB,gBAAgB,CAM3B"}

package/lib/internal/_stringLengthGte.mjs

@@ -2,15 +2,20 @@
 /**
 * Test whether a string has at least the given number of code points.
 *
-* Iteration stops as soon as the count is reached, so a long string is not
-* scanned to its end.
+* Twice the requested minimum in UTF-16 units guarantees enough code points.
+* Other inputs are counted only until the minimum is reached.
 *
-* @evidence contracts/common.md#principled-implementation The iterator is consumed only until the count reaches the requested minimum, which decides the lower bound without scanning the whole string; a minimum of zero is true at once.
+* @evidence contracts/common.md#principled-implementation Each code point occupies at most two UTF-16 units, so code-unit length at least twice the minimum proves the code-point bound. Otherwise iteration stops at the minimum; nonpositive minima remain true and NaN remains false.
 * @evidence contracts/common.md#clear-and-simple-design One loop with an early return.
 * @evidence contracts/common.md#prohibited-implementation-shortcuts The unit is code points.
 * @evidence contracts/common.md#meaningful-documentation The doc states the early return and the code point unit.
+* @evidence contracts/performance.md#efficient-algorithms The code-unit lower bound accepts in constant time without allocating an iterator; ambiguous inputs retain the bounded code-point walk and constant auxiliary space.
+*
+* @evidenceExclude contracts/performance.md#reuse-equivalent-work Each call depends on its own primitive string and bound; this predicate coordinates no repeated requests or shared computation.
+* @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate retains no state or handles after returning; iteration and scalar counters are call-local.
 */
 const _stringLengthGte = (value, length) => {
+	if (value.length >= length * 2) return true;
 	let count = 0;
 	if (length <= count) return true;
 	for (const _ch of value) if (length <= ++count) return true;

package/lib/internal/_stringLengthGte.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"_stringLengthGte.mjs","names":[],"sources":["../../src/internal/_stringLengthGte.ts"],"sourcesContent":["/**\n * Test whether a string has at least the given number of code points.\n *\n * Iteration stops as soon as the count is reached, so a long string is not\n * scanned to its end.\n *\n * @evidence contracts/common.md#principled-implementation The iterator is consumed only until the count reaches the requested minimum, which decides the lower bound without scanning the whole string; a minimum of zero is true at once.\n * @evidence contracts/common.md#clear-and-simple-design One loop with an early return.\n * @evidence contracts/common.md#prohibited-implementation-shortcuts The unit is code points.\n * @evidence contracts/common.md#meaningful-documentation The doc states the early return and the code point unit.\n */\nexport const _stringLengthGte = (value: string, length: number): boolean => {\n  let count: number = 0;\n  if (length <= count) return true;\n  for (const _ch of value) if (length <= ++count) return true;\n  return false;\n};\n"],"mappings":";;;;;;;;;;;;AAWA,MAAa,oBAAoB,OAAe,WAA4B;CAC1E,IAAI,QAAgB;CACpB,IAAI,UAAU,OAAO,OAAO;CAC5B,KAAK,MAAM,OAAO,OAAO,IAAI,UAAU,EAAE,OAAO,OAAO;CACvD,OAAO;AACT"}
+{"version":3,"file":"_stringLengthGte.mjs","names":[],"sources":["../../src/internal/_stringLengthGte.ts"],"sourcesContent":["/**\n * Test whether a string has at least the given number of code points.\n *\n * Twice the requested minimum in UTF-16 units guarantees enough code points.\n * Other inputs are counted only until the minimum is reached.\n *\n * @evidence contracts/common.md#principled-implementation Each code point occupies at most two UTF-16 units, so code-unit length at least twice the minimum proves the code-point bound. Otherwise iteration stops at the minimum; nonpositive minima remain true and NaN remains false.\n * @evidence contracts/common.md#clear-and-simple-design One loop with an early return.\n * @evidence contracts/common.md#prohibited-implementation-shortcuts The unit is code points.\n * @evidence contracts/common.md#meaningful-documentation The doc states the early return and the code point unit.\n * @evidence contracts/performance.md#efficient-algorithms The code-unit lower bound accepts in constant time without allocating an iterator; ambiguous inputs retain the bounded code-point walk and constant auxiliary space.\n *\n * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each call depends on its own primitive string and bound; this predicate coordinates no repeated requests or shared computation.\n * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate retains no state or handles after returning; iteration and scalar counters are call-local.\n */\nexport const _stringLengthGte = (value: string, length: number): boolean => {\n  if (value.length >= length * 2) return true;\n  let count: number = 0;\n  if (length <= count) return true;\n  for (const _ch of value) if (length <= ++count) return true;\n  return false;\n};\n"],"mappings":";;;;;;;;;;;;;;;;AAeA,MAAa,oBAAoB,OAAe,WAA4B;CAC1E,IAAI,MAAM,UAAU,SAAS,GAAG,OAAO;CACvC,IAAI,QAAgB;CACpB,IAAI,UAAU,OAAO,OAAO;CAC5B,KAAK,MAAM,OAAO,OAAO,IAAI,UAAU,EAAE,OAAO,OAAO;CACvD,OAAO;AACT"}

package/lib/internal/_stringLengthLte.d.ts

@@ -1,12 +1,16 @@
 /**
  * Test whether a string has at most the given number of code points.
  *
- * Iteration stops as soon as the count is exceeded, so a long string is not
- * scanned to its end.
+ * UTF-16 length decides inputs whose code units already fit the bound. Other
+ * inputs are counted only until the maximum is exceeded.
  *
- * @evidence contracts/common.md#principled-implementation The iterator is consumed until the count exceeds the maximum, which decides the upper bound without scanning past it; a negative maximum is false at once.
+ * @evidence contracts/common.md#principled-implementation Each code point occupies one or two UTF-16 units, so code-unit length at most the maximum proves the code-point bound. Otherwise iteration stops once the maximum is exceeded; negative and NaN maxima remain false.
  * @evidence contracts/common.md#clear-and-simple-design One loop with an early return.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts The unit is code points.
  * @evidence contracts/common.md#meaningful-documentation The doc states the early return and the code point unit.
+ * @evidence contracts/performance.md#efficient-algorithms The code-unit upper bound accepts in constant time without allocating an iterator; ambiguous inputs retain the bounded code-point walk and constant auxiliary space.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each call depends on its own primitive string and bound; this predicate coordinates no repeated requests or shared computation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate retains no state or handles after returning; iteration and scalar counters are call-local.
  */
 export declare const _stringLengthLte: (value: string, length: number) => boolean;

package/lib/internal/_stringLengthLte.js

@@ -4,15 +4,21 @@ exports._stringLengthLte = void 0;
 /**
  * Test whether a string has at most the given number of code points.
  *
- * Iteration stops as soon as the count is exceeded, so a long string is not
- * scanned to its end.
+ * UTF-16 length decides inputs whose code units already fit the bound. Other
+ * inputs are counted only until the maximum is exceeded.
  *
- * @evidence contracts/common.md#principled-implementation The iterator is consumed until the count exceeds the maximum, which decides the upper bound without scanning past it; a negative maximum is false at once.
+ * @evidence contracts/common.md#principled-implementation Each code point occupies one or two UTF-16 units, so code-unit length at most the maximum proves the code-point bound. Otherwise iteration stops once the maximum is exceeded; negative and NaN maxima remain false.
  * @evidence contracts/common.md#clear-and-simple-design One loop with an early return.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts The unit is code points.
  * @evidence contracts/common.md#meaningful-documentation The doc states the early return and the code point unit.
+ * @evidence contracts/performance.md#efficient-algorithms The code-unit upper bound accepts in constant time without allocating an iterator; ambiguous inputs retain the bounded code-point walk and constant auxiliary space.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each call depends on its own primitive string and bound; this predicate coordinates no repeated requests or shared computation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate retains no state or handles after returning; iteration and scalar counters are call-local.
  */
 const _stringLengthLte = (value, length) => {
+    if (value.length <= length)
+        return true;
     let count = 0;
     if (!(count <= length))
         return false;

package/lib/internal/_stringLengthLte.js.map

@@ -1 +1 @@
-{"version":3,"file":"_stringLengthLte.js","sources":["../../src/internal/_stringLengthLte.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;GAUG;AACI,MAAM,gBAAgB,GAAG,CAAC,KAAa,EAAE,MAAc,EAAW,EAAE;IACzE,IAAI,KAAK,GAAW,CAAC,CAAC;IACtB,IAAI,CAAC,CAAC,KAAK,IAAI,MAAM,CAAC;QAAE,OAAO,KAAK,CAAC;IACrC,KAAK,MAAM,GAAG,IAAI,KAAK;QAAE,IAAI,CAAC,CAAC,EAAE,KAAK,IAAI,MAAM,CAAC;YAAE,OAAO,KAAK,CAAC;IAChE,OAAO,IAAI,CAAC;AACd,CAAC,CAAC;AALW,QAAA,gBAAgB,GAAhB,gBAAgB,CAK3B"}
+{"version":3,"file":"_stringLengthLte.js","sources":["../../src/internal/_stringLengthLte.ts"],"names":[],"mappings":";;;AAAA;;;;;;;;;;;;;;GAcG;AACI,MAAM,gBAAgB,GAAG,CAAC,KAAa,EAAE,MAAc,EAAW,EAAE;IACzE,IAAI,KAAK,CAAC,MAAM,IAAI,MAAM;QAAE,OAAO,IAAI,CAAC;IACxC,IAAI,KAAK,GAAW,CAAC,CAAC;IACtB,IAAI,CAAC,CAAC,KAAK,IAAI,MAAM,CAAC;QAAE,OAAO,KAAK,CAAC;IACrC,KAAK,MAAM,GAAG,IAAI,KAAK;QAAE,IAAI,CAAC,CAAC,EAAE,KAAK,IAAI,MAAM,CAAC;YAAE,OAAO,KAAK,CAAC;IAChE,OAAO,IAAI,CAAC;AACd,CAAC,CAAC;AANW,QAAA,gBAAgB,GAAhB,gBAAgB,CAM3B"}

package/lib/internal/_stringLengthLte.mjs

@@ -2,15 +2,20 @@
 /**
 * Test whether a string has at most the given number of code points.
 *
-* Iteration stops as soon as the count is exceeded, so a long string is not
-* scanned to its end.
+* UTF-16 length decides inputs whose code units already fit the bound. Other
+* inputs are counted only until the maximum is exceeded.
 *
-* @evidence contracts/common.md#principled-implementation The iterator is consumed until the count exceeds the maximum, which decides the upper bound without scanning past it; a negative maximum is false at once.
+* @evidence contracts/common.md#principled-implementation Each code point occupies one or two UTF-16 units, so code-unit length at most the maximum proves the code-point bound. Otherwise iteration stops once the maximum is exceeded; negative and NaN maxima remain false.
 * @evidence contracts/common.md#clear-and-simple-design One loop with an early return.
 * @evidence contracts/common.md#prohibited-implementation-shortcuts The unit is code points.
 * @evidence contracts/common.md#meaningful-documentation The doc states the early return and the code point unit.
+* @evidence contracts/performance.md#efficient-algorithms The code-unit upper bound accepts in constant time without allocating an iterator; ambiguous inputs retain the bounded code-point walk and constant auxiliary space.
+*
+* @evidenceExclude contracts/performance.md#reuse-equivalent-work Each call depends on its own primitive string and bound; this predicate coordinates no repeated requests or shared computation.
+* @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate retains no state or handles after returning; iteration and scalar counters are call-local.
 */
 const _stringLengthLte = (value, length) => {
+	if (value.length <= length) return true;
 	let count = 0;
 	if (!(count <= length)) return false;
 	for (const _ch of value) if (!(++count <= length)) return false;

package/lib/internal/_stringLengthLte.mjs.map

@@ -1 +1 @@
-{"version":3,"file":"_stringLengthLte.mjs","names":[],"sources":["../../src/internal/_stringLengthLte.ts"],"sourcesContent":["/**\n * Test whether a string has at most the given number of code points.\n *\n * Iteration stops as soon as the count is exceeded, so a long string is not\n * scanned to its end.\n *\n * @evidence contracts/common.md#principled-implementation The iterator is consumed until the count exceeds the maximum, which decides the upper bound without scanning past it; a negative maximum is false at once.\n * @evidence contracts/common.md#clear-and-simple-design One loop with an early return.\n * @evidence contracts/common.md#prohibited-implementation-shortcuts The unit is code points.\n * @evidence contracts/common.md#meaningful-documentation The doc states the early return and the code point unit.\n */\nexport const _stringLengthLte = (value: string, length: number): boolean => {\n  let count: number = 0;\n  if (!(count <= length)) return false;\n  for (const _ch of value) if (!(++count <= length)) return false;\n  return true;\n};\n"],"mappings":";;;;;;;;;;;;AAWA,MAAa,oBAAoB,OAAe,WAA4B;CAC1E,IAAI,QAAgB;CACpB,IAAI,EAAE,SAAS,SAAS,OAAO;CAC/B,KAAK,MAAM,OAAO,OAAO,IAAI,EAAE,EAAE,SAAS,SAAS,OAAO;CAC1D,OAAO;AACT"}
+{"version":3,"file":"_stringLengthLte.mjs","names":[],"sources":["../../src/internal/_stringLengthLte.ts"],"sourcesContent":["/**\n * Test whether a string has at most the given number of code points.\n *\n * UTF-16 length decides inputs whose code units already fit the bound. Other\n * inputs are counted only until the maximum is exceeded.\n *\n * @evidence contracts/common.md#principled-implementation Each code point occupies one or two UTF-16 units, so code-unit length at most the maximum proves the code-point bound. Otherwise iteration stops once the maximum is exceeded; negative and NaN maxima remain false.\n * @evidence contracts/common.md#clear-and-simple-design One loop with an early return.\n * @evidence contracts/common.md#prohibited-implementation-shortcuts The unit is code points.\n * @evidence contracts/common.md#meaningful-documentation The doc states the early return and the code point unit.\n * @evidence contracts/performance.md#efficient-algorithms The code-unit upper bound accepts in constant time without allocating an iterator; ambiguous inputs retain the bounded code-point walk and constant auxiliary space.\n *\n * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each call depends on its own primitive string and bound; this predicate coordinates no repeated requests or shared computation.\n * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate retains no state or handles after returning; iteration and scalar counters are call-local.\n */\nexport const _stringLengthLte = (value: string, length: number): boolean => {\n  if (value.length <= length) return true;\n  let count: number = 0;\n  if (!(count <= length)) return false;\n  for (const _ch of value) if (!(++count <= length)) return false;\n  return true;\n};\n"],"mappings":";;;;;;;;;;;;;;;;AAeA,MAAa,oBAAoB,OAAe,WAA4B;CAC1E,IAAI,MAAM,UAAU,QAAQ,OAAO;CACnC,IAAI,QAAgB;CACpB,IAAI,EAAE,SAAS,SAAS,OAAO;CAC/B,KAAK,MAAM,OAAO,OAAO,IAAI,EAAE,EAAE,SAAS,SAAS,OAAO;CAC1D,OAAO;AACT"}

package/native/core/context/ImportProgrammer.go

@@ -9,7 +9,7 @@ import (
 )
 
 // ImportProgrammer collects the imports that generated code needs and builds the
-// references to them.
+// references to them. It also collects lazily initialized pattern slots.
 //
 // In its default mode references are plain identifiers and ToStatements writes
 // named, default and namespace imports. After SetEmitContext, every file becomes
@@ -17,14 +17,16 @@ import (
 // name, so the compiler's module transform binds them. It is not safe for
 // concurrent use.
 //
-// @evidence contracts/common.md#principled-implementation Requests are recorded per file with their insertion order and each file is emitted once, either as named, default and namespace imports in the legacy mode or as one namespace import with member accesses on a generated unique name in emit-context mode, so the compiler's module transform decides the final CommonJS aliasing. Internal helpers are always imported from the typia package's internal folder under prefixed aliases.
+// @evidence contracts/common.md#principled-implementation Requests are recorded per file with their insertion order and each file is emitted once, either as named, default and namespace imports in the legacy mode or as one namespace import with member accesses on a generated unique name in emit-context mode, so the compiler's module transform decides the final CommonJS aliasing. Internal helpers use typia's internal folder. Static pattern sources share file-local lazy slots only when the compiler can allocate collision-safe names.
 // @evidence contracts/common.md#clear-and-simple-design One type with private asset records and helpers for module identifiers, ranks, member construction and aliases; the two emission modes share the recording code.
 // @evidence contracts/common.md#prohibited-implementation-shortcuts Ordering uses a rank table over internal helper names and first use, not special-casing of a consumer. It is not safe for concurrent use, which the doc states.
 // @evidence contracts/common.md#meaningful-documentation The doc describes both modes and the concurrency limit, and the field comment explains emit mode.
 type ImportProgrammer struct {
-  assets_  map[string]*importProgrammer_asset
-  order_   []string
-  options_ ImportProgrammer_IOptions
+  assets_       map[string]*importProgrammer_asset
+  order_        []string
+  options_      ImportProgrammer_IOptions
+  patterns_     map[string]*shimast.Node
+  patternOrder_ []string
   // emit_ switches import emission to AST-integration mode. When set, imports
   // become namespace imports created by emit_.Factory, and every reference is a
   // member access on a cloned unique name so tsgo's module transform owns the
@@ -332,14 +334,15 @@ func (p *ImportProgrammer) GetInternalText(name string) string {
   return alias
 }
 
-// ToStatements returns the import statements for everything requested. Files are
-// ordered by rank, with the internal helper files grouped by kind, and by first
-// use within a rank.
+// ToStatements returns the requested imports followed by lazy pattern slots.
+// Import files are ordered by rank, with internal helpers grouped by kind, and
+// by first use within a rank.
 //
-// @evidence contracts/common.md#principled-implementation Files are stable-sorted by a rank that groups internal helpers by kind and keeps insertion order within a rank, then emitted as one namespace import with optional constants in emit mode, or as namespace, default and named imports in the legacy mode, where a type-only default gets the type keyword.
+// @evidence contracts/common.md#principled-implementation Files are stable-sorted by a rank that groups internal helpers by kind and keeps insertion order within a rank, then emitted as one namespace import with optional constants in emit mode, or as namespace, default and named imports in the legacy mode, where a type-only default gets the type keyword. Pattern slots follow as uninitialized var declarations in first-use order.
 // @evidence contracts/common.md#clear-and-simple-design One method with the two mode branches and the rank helper.
 // @evidence contracts/common.md#prohibited-implementation-shortcuts The ranking is a fixed table and the order is deterministic.
 // @evidence contracts/common.md#meaningful-documentation The doc states the order and the two forms.
+// @evidence contracts/performance.md#efficient-algorithms Sorting A import assets costs O(A log A); pattern declarations follow in one O(P) first-use walk. Output allocation is proportional to the declarations that must be emitted, without scanning authored input strings or allocating a runtime lookup table.
 func (p *ImportProgrammer) ToStatements() []*shimast.Node {
   f := NodeFactoryOf(p.emit_)
   statements := []*shimast.Node{}
@@ -448,6 +451,13 @@ func (p *ImportProgrammer) ToStatements() []*shimast.Node {
       ))
     }
   }
+  for _, source := range p.patternOrder_ {
+    statements = append(statements, f.NewVariableStatement(nil,
+      f.NewVariableDeclarationList(f.NewNodeList([]*shimast.Node{
+        f.NewVariableDeclaration(p.patterns_[source].Clone(f), nil, nil, nil),
+      }), shimast.NodeFlagsNone),
+    ))
+  }
   return statements
 }
 

package/native/core/context/ImportProgrammerPattern.go

@@ -0,0 +1,36 @@
+package context
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+// Pattern reuses a flag-free RegExp after its first successful construction.
+// The constructor stays at the check site, so invalid sources still throw only
+// when the string check is reached. File-scoped var slots also work when a
+// circular import invokes a hoisted function before this module's body runs.
+// Without an emit context, retain the constructor: the standalone factory has
+// no compiler name-collision information for a file-scoped generated slot.
+//
+// @evidence contracts/common.md#principled-implementation A flag-free RegExp test does not advance lastIndex, so checks with the same source can share the compiled object. Nullish assignment records only successful construction and preserves lazy SyntaxError timing. Uninitialized var declarations are hoisted and do not reset an early circular-import initialization. The compiler supplies collision-safe names; without that capability, the original constructor is returned without introducing a binding.
+// @evidence contracts/common.md#clear-and-simple-design The file's existing statement collector owns one generated slot per distinct source and returns its lazy initialization expression.
+// @evidence contracts/common.md#prohibited-implementation-shortcuts Only the caller's verified static flag-free pattern expressions use this method; arbitrary custom validators remain untouched.
+// @evidence contracts/common.md#meaningful-documentation The comment explains reuse, lazy construction and the var declaration.
+// @evidence contracts/performance.md#efficient-algorithms Source lookup uses the file's map and each generated check performs one nullish guard instead of constructing another RegExp.
+// @evidence contracts/performance.md#reuse-equivalent-work Standard JavaScript RegExp objects with identical source and no flags have equivalent stateless test behavior; the importer is scoped to one transformed source file and not shared between programs.
+// @evidence contracts/performance.md#bound-retention-and-release-resources Generation retains one slot per distinct authored pattern until the file transform ends; runtime retains at most one RegExp per slot for the containing module's lifetime, with no runtime-keyed cache.
+func (p *ImportProgrammer) Pattern(source string, constructor *shimast.Node) *shimast.Node {
+  if p.emit_ == nil {
+    return constructor
+  }
+  f := NodeFactoryOf(p.emit_)
+  name := p.patterns_[source]
+  if name == nil {
+    if p.patterns_ == nil {
+      p.patterns_ = map[string]*shimast.Node{}
+    }
+    name = p.emit_.Factory.NewUniqueName("__" + p.options_.InternalPrefix + "pattern")
+    p.patterns_[source] = name
+    p.patternOrder_ = append(p.patternOrder_, source)
+  }
+  return f.NewParenthesizedExpression(f.NewBinaryExpression(nil,
+    name.Clone(f), nil, f.NewToken(shimast.KindQuestionQuestionEqualsToken), constructor,
+  ))
+}

package/native/core/programmers/iterate/check_string.go

@@ -24,7 +24,7 @@ type Check_stringProps struct {
 // Check_string builds the check entry of a string atomic: a `typeof input ===
 // "string"` guard plus the atomic's type-tag conditions.
 //
-// @evidence contracts/common.md#principled-implementation It builds the check entry of a string atomic: a `typeof input === "string"` guard plus the atomic's type-tag conditions.
+// @evidence contracts/common.md#principled-implementation It builds the string guard and type-tag conditions. A static flag-free RegExp(source).test(input) whose source agrees with pattern metadata uses the file's lazy reusable slot; other validation expressions retain their authored AST.
 // @evidence contracts/common.md#clear-and-simple-design One exported function; the pieces that repeat live in private helpers of the same file.
 // @evidence contracts/common.md#prohibited-implementation-shortcuts Its inputs are its arguments and the context they carry, and it keeps no state of its own.
 // @evidence contracts/common.md#meaningful-documentation The doc states what it builds.
@@ -50,9 +50,10 @@ func check_string_type_tags(props Check_stringProps) [][]nativehelpers.ICheckEnt
     tags := check_string_filter_validate(row)
     conditions := make([]nativehelpers.ICheckEntry_ICondition, 0, len(tags))
     for _, tag := range tags {
+      expression := check_string_transpile(props.Context, tag)(props.Input)
       conditions = append(conditions, nativehelpers.ICheckEntry_ICondition{
         Expected:   "string & " + tag.Name,
-        Expression: check_string_transpile(props.Context, tag.Validate)(props.Input),
+        Expression: expression,
       })
     }
     for _, tag := range row {
@@ -68,6 +69,36 @@ func check_string_type_tags(props Check_stringProps) [][]nativehelpers.ICheckEnt
   return output
 }
 
+// Recognize only the standard flag-free RegExp(source).test(input) form. A
+// custom pattern-kind tag may supply arbitrary validation code or flags, and
+// must retain that code and its state rather than being lowered from value alone.
+func check_string_pattern(context nativecontext.ITypiaContext, tag nativemetadata.IMetadataTypeTag, input *shimast.Expression, expression *shimast.Node) *shimast.Node {
+  source, ok := tag.Value.(string)
+  if !ok || tag.Kind != "pattern" || context.Importer == nil || expression.Kind != shimast.KindCallExpression {
+    return expression
+  }
+  test := expression.AsCallExpression()
+  if test.Arguments == nil || len(test.Arguments.Nodes) != 1 || test.Arguments.Nodes[0] != input || test.Expression.Kind != shimast.KindPropertyAccessExpression {
+    return expression
+  }
+  member := test.Expression.AsPropertyAccessExpression()
+  if member.Name().Text() != "test" || member.Expression.Kind != shimast.KindCallExpression {
+    return expression
+  }
+  constructor := member.Expression.AsCallExpression()
+  if constructor.Expression.Kind != shimast.KindIdentifier || constructor.Expression.Text() != "RegExp" || constructor.Arguments == nil || len(constructor.Arguments.Nodes) != 1 {
+    return expression
+  }
+  argument := constructor.Arguments.Nodes[0]
+  if !shimast.IsStringLiteral(argument) || argument.Text() != source {
+    return expression
+  }
+  f := nativecontext.NodeFactoryOf(context.Emit)
+  return f.NewCallExpression(f.NewPropertyAccessExpression(
+    context.Importer.Pattern(source, member.Expression), nil, f.NewIdentifier("test"), shimast.NodeFlagsNone,
+  ), nil, nil, test.Arguments, shimast.NodeFlagsNone)
+}
+
 func check_string_filter_validate(row []nativemetadata.IMetadataTypeTag) []nativemetadata.IMetadataTypeTag {
   tags := []nativemetadata.IMetadataTypeTag{}
   for _, tag := range row {
@@ -78,13 +109,18 @@ func check_string_filter_validate(row []nativemetadata.IMetadataTypeTag) []nativ
   return tags
 }
 
-func check_string_transpile(context nativecontext.ITypiaContext, script string) func(input *shimast.Expression) *shimast.Node {
+// The same lowering serves ordinary strings, whole-template tags and captured
+// placeholder/backtracking checks, so every standard Pattern shares the cache.
+func check_string_transpile(context nativecontext.ITypiaContext, tag nativemetadata.IMetadataTypeTag) func(input *shimast.Expression) *shimast.Node {
   var importer nativefactories.ExpressionFactory_Importer
   if v := context.Importer; v != nil {
     importer = v
   }
-  return nativefactories.ExpressionFactory.Transpile(nativefactories.ExpressionFactory_TranspileProps{
+  transpile := nativefactories.ExpressionFactory.Transpile(nativefactories.ExpressionFactory_TranspileProps{
     Importer: importer,
-    Script:   script,
+    Script:   tag.Validate,
   }, context.Emit)
+  return func(input *shimast.Expression) *shimast.Node {
+    return check_string_pattern(context, tag, input, transpile(input))
+  }
 }

package/native/core/programmers/iterate/check_string_pattern_test.go

@@ -0,0 +1,91 @@
+package iterate
+
+import (
+  "testing"
+
+  shimast "github.com/microsoft/typescript-go/shim/ast"
+  shimprinter "github.com/microsoft/typescript-go/shim/printer"
+  nativecontext "github.com/samchon/typia/packages/typia/native/core/context"
+  nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+// TestCheckStringCachesOnlyStaticPatterns verifies the string check's cache boundary.
+//
+// Pattern-kind metadata alone cannot justify replacing arbitrary validation
+// code. Only a flag-free constructor with the authored source and input has
+// the standard tag's stateless behavior.
+//
+//  1. Build real string-check expressions for standard and custom tag forms.
+//  2. Require one lazy var slot for repeated standard sources in compiler mode.
+//  3. Preserve inline checks without new names in standalone mode, and preserve
+//     custom expressions in both modes.
+//
+// @evidence contracts/testing.md#behavioral-verification Check_string builds AST checks from tag metadata. Standard and empty sources register one lazy uninitialized var after repeated compiler-integrated calls; flags, altered source, altered input, arbitrary predicates and other tag kinds register none. Standalone mode retains the inline constructor and emits no potentially conflicting name.
+// @evidence contracts/testing.md#independent-expectations A flag-free RegExp(source).test(input) can reuse one stateless object. Additional flags or authored expressions are independent behavior and must remain unchanged; uninitialized var slots preserve lazy and early-module use.
+// @evidence contracts/testing.md#distinguishing-cases Standard, empty and invalid sources have custom flags, mismatched source, mismatched input, custom predicate, non-pattern kind and absent importer negative twins. Two distinct sources require two slots; repeated requests reuse one. Standalone mode contrasts with compiler mode because it cannot safely allocate a name beside authored declarations.
+// @evidence contracts/testing.md#execution-ownership The native Go suite discovers this in-process unit test. It calls the real checker builder and importer with in-memory AST and metadata; no compiler artifact or JavaScript subprocess is needed. The schema E2E case owns actual module lowering and construction counts.
+func TestCheckStringCachesOnlyStaticPatterns(t *testing.T) {
+  for _, emit := range []*shimprinter.EmitContext{nil, shimprinter.NewEmitContext()} {
+    for _, row := range []struct {
+      source string
+      script string
+      kind   string
+      cached bool
+    }{
+      {"x", `RegExp("x").test($input)`, "pattern", true},
+      {"", `RegExp("").test($input)`, "pattern", true},
+      {"[", `RegExp("[").test($input)`, "pattern", true},
+      {"x", `RegExp("x", "g").test($input)`, "pattern", false},
+      {"x", `RegExp("y").test($input)`, "pattern", false},
+      {"x", `RegExp("x").test("other")`, "pattern", false},
+      {"x", `$input === "allow"`, "pattern", false},
+      {"x", `RegExp("x").test($input)`, "custom", false},
+    } {
+      importer := nativecontext.NewImportProgrammer()
+      if emit != nil {
+        importer.SetEmitContext(emit)
+      }
+      props := Check_stringProps{
+        Context: nativecontext.ITypiaContext{Emit: emit, Importer: importer},
+        Input:   nativecontext.NodeFactoryOf(emit).NewIdentifier("input"),
+        Atomic: &nativemetadata.MetadataAtomic{Type: "string", Tags: [][]nativemetadata.IMetadataTypeTag{{{
+          Target: "string", Name: "test", Kind: row.kind, Value: row.source, Validate: row.script,
+        }}}},
+      }
+      first := Check_string(props).Conditions[0][0].Expression
+      Check_string(props)
+      statements := importer.ToStatements()
+      expected := 0
+      if row.cached && emit != nil {
+        expected = 1
+      }
+      if len(statements) != expected {
+        t.Fatalf("%s: expected %d cache slots, got %d", row.script, expected, len(statements))
+      }
+      if row.cached && emit == nil {
+        receiver := first.AsCallExpression().Expression.AsPropertyAccessExpression().Expression
+        if receiver.Kind != shimast.KindCallExpression {
+          t.Fatal("standalone mode must preserve the inline constructor without a new binding")
+        }
+      }
+      if expected != 0 {
+        declaration := statements[0].AsVariableStatement().DeclarationList.AsVariableDeclarationList()
+        if declaration.Flags&(shimast.NodeFlagsLet|shimast.NodeFlagsConst) != 0 || declaration.Declarations.Nodes[0].AsVariableDeclaration().Initializer != nil {
+          t.Fatalf("%s: cache must use an uninitialized var", row.script)
+        }
+        receiver := first.AsCallExpression().Expression.AsPropertyAccessExpression().Expression
+        if receiver.Kind != shimast.KindParenthesizedExpression || receiver.AsParenthesizedExpression().Expression.AsBinaryExpression().OperatorToken.Kind != shimast.KindQuestionQuestionEqualsToken {
+          t.Fatalf("%s: construction must be lazy", row.script)
+        }
+        props.Atomic.Tags[0][0].Value = "different"
+        props.Atomic.Tags[0][0].Validate = `RegExp("different").test($input)`
+        Check_string(props)
+        if len(importer.ToStatements()) != 2 {
+          t.Fatal("distinct sources must have distinct slots")
+        }
+      }
+      props.Context.Importer = nil
+      Check_string(props)
+    }
+  }
+}

package/native/core/programmers/iterate/check_template.go

@@ -30,7 +30,7 @@ type Check_templateProps struct {
 // guard plus one `RegExp(...).test` per template, with the type tags inlined
 // into the member when several templates are neighbors.
 //
-// @evidence contracts/common.md#principled-implementation It builds the check entry of template literal types: a string guard plus one `RegExp(...).test` per template, with the type tags inlined into the member when several templates are neighbors.
+// @evidence contracts/common.md#principled-implementation It builds the check entry of template literal types: a string guard plus one structural regex per template. Whole-string and captured-placeholder tag conditions use the common string-tag lowering, including backtracking and union members, so standard Pattern tags share the file cache without changing structural matching.
 // @evidence contracts/common.md#clear-and-simple-design One exported function; the pieces that repeat live in private helpers of the same file.
 // @evidence contracts/common.md#prohibited-implementation-shortcuts Its inputs are its arguments and the context they carry, and it keeps no state of its own.
 // @evidence contracts/common.md#meaningful-documentation The doc states what it builds.
@@ -125,7 +125,7 @@ func check_template_type_tags(props Check_templateProps, tpl *nativemetadata.Met
     for _, tag := range tags {
       conditions = append(conditions, nativehelpers.ICheckEntry_ICondition{
         Expected:   tpl.GetBaseName() + " & " + tag.Name,
-        Expression: check_string_transpile(props.Context, tag.Validate)(props.Input),
+        Expression: check_string_transpile(props.Context, tag)(props.Input),
       })
     }
     for _, tag := range row {
@@ -253,7 +253,7 @@ func check_template_value_conditions(props Check_templateProps, base string, ato
       for _, tag := range check_string_filter_validate(row) {
         conditions = append(conditions, nativehelpers.ICheckEntry_ICondition{
           Expected:   base + " & " + tag.Name,
-          Expression: check_string_transpile(props.Context, tag.Validate)(input),
+          Expression: check_string_transpile(props.Context, tag)(input),
         })
       }
       for _, tag := range row {
@@ -611,7 +611,7 @@ func check_template_inline_tags(props Check_templateProps, tpl *nativemetadata.M
     tags := check_string_filter_validate(row)
     expressions := make([]*shimast.Node, 0, len(tags))
     for _, tag := range tags {
-      expressions = append(expressions, check_string_transpile(props.Context, tag.Validate)(props.Input))
+      expressions = append(expressions, check_string_transpile(props.Context, tag)(props.Input))
     }
     for _, tag := range row {
       if condition := check_exclude_condition("string", tag, props.Input, props.Emit); condition != nil {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "typia",
-  "version": "15.2.1",
+  "version": "15.2.2",
   "description": "Superfast runtime validators with only one line",
   "main": "lib/index.js",
   "exports": {
@@ -43,8 +43,8 @@
   "homepage": "https://typia.io",
   "dependencies": {
     "randexp": "^0.5.3",
-    "@typia/interface": "^15.2.1",
-    "@typia/utils": "^15.2.1"
+    "@typia/interface": "^15.2.2",
+    "@typia/utils": "^15.2.2"
   },
   "peerDependencies": {
     "ttsc": ">=0.34.1"

package/src/internal/_stringLengthGte.ts

@@ -1,15 +1,20 @@
 /**
  * Test whether a string has at least the given number of code points.
  *
- * Iteration stops as soon as the count is reached, so a long string is not
- * scanned to its end.
+ * Twice the requested minimum in UTF-16 units guarantees enough code points.
+ * Other inputs are counted only until the minimum is reached.
  *
- * @evidence contracts/common.md#principled-implementation The iterator is consumed only until the count reaches the requested minimum, which decides the lower bound without scanning the whole string; a minimum of zero is true at once.
+ * @evidence contracts/common.md#principled-implementation Each code point occupies at most two UTF-16 units, so code-unit length at least twice the minimum proves the code-point bound. Otherwise iteration stops at the minimum; nonpositive minima remain true and NaN remains false.
  * @evidence contracts/common.md#clear-and-simple-design One loop with an early return.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts The unit is code points.
  * @evidence contracts/common.md#meaningful-documentation The doc states the early return and the code point unit.
+ * @evidence contracts/performance.md#efficient-algorithms The code-unit lower bound accepts in constant time without allocating an iterator; ambiguous inputs retain the bounded code-point walk and constant auxiliary space.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each call depends on its own primitive string and bound; this predicate coordinates no repeated requests or shared computation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate retains no state or handles after returning; iteration and scalar counters are call-local.
  */
 export const _stringLengthGte = (value: string, length: number): boolean => {
+  if (value.length >= length * 2) return true;
   let count: number = 0;
   if (length <= count) return true;
   for (const _ch of value) if (length <= ++count) return true;

package/src/internal/_stringLengthLte.ts

@@ -1,15 +1,20 @@
 /**
  * Test whether a string has at most the given number of code points.
  *
- * Iteration stops as soon as the count is exceeded, so a long string is not
- * scanned to its end.
+ * UTF-16 length decides inputs whose code units already fit the bound. Other
+ * inputs are counted only until the maximum is exceeded.
  *
- * @evidence contracts/common.md#principled-implementation The iterator is consumed until the count exceeds the maximum, which decides the upper bound without scanning past it; a negative maximum is false at once.
+ * @evidence contracts/common.md#principled-implementation Each code point occupies one or two UTF-16 units, so code-unit length at most the maximum proves the code-point bound. Otherwise iteration stops once the maximum is exceeded; negative and NaN maxima remain false.
  * @evidence contracts/common.md#clear-and-simple-design One loop with an early return.
  * @evidence contracts/common.md#prohibited-implementation-shortcuts The unit is code points.
  * @evidence contracts/common.md#meaningful-documentation The doc states the early return and the code point unit.
+ * @evidence contracts/performance.md#efficient-algorithms The code-unit upper bound accepts in constant time without allocating an iterator; ambiguous inputs retain the bounded code-point walk and constant auxiliary space.
+ *
+ * @evidenceExclude contracts/performance.md#reuse-equivalent-work Each call depends on its own primitive string and bound; this predicate coordinates no repeated requests or shared computation.
+ * @evidenceExclude contracts/performance.md#bound-retention-and-release-resources The predicate retains no state or handles after returning; iteration and scalar counters are call-local.
  */
 export const _stringLengthLte = (value: string, length: number): boolean => {
+  if (value.length <= length) return true;
   let count: number = 0;
   if (!(count <= length)) return false;
   for (const _ch of value) if (!(++count <= length)) return false;