typia 13.0.0-dev.20260427-3 → 13.0.0-dev.20260430

package/native/core/context/TransformerError.go

@@ -0,0 +1,117 @@
+package context
+
+import (
+	"encoding/json"
+	"strings"
+
+	nativemetadata "github.com/samchon/typia/packages/typia/native/core/schemas/metadata"
+)
+
+type TransformerError struct {
+	Code    string
+	Message string
+}
+
+func NewTransformerError(props TransformerError_IProps) *TransformerError {
+	return &TransformerError{
+		Code:    props.Code,
+		Message: props.Message,
+	}
+}
+
+func (err *TransformerError) Error() string {
+	return err.Message
+}
+
+type TransformerError_IProps struct {
+	Code    string
+	Message string
+}
+
+type TransformerError_MetadataFactory_IError struct {
+	Name     string
+	Explore  TransformerError_MetadataFactory_IExplore
+	Messages []string
+}
+
+type TransformerError_MetadataFactory_IExplore struct {
+	Object    *nativemetadata.MetadataObjectType
+	Property  any
+	Parameter any
+	Output    bool
+}
+
+func TransformerError_from(props struct {
+	Code   string
+	Errors []TransformerError_MetadataFactory_IError
+}) *TransformerError {
+	lines := make([]string, 0, len(props.Errors))
+	for _, err := range props.Errors {
+		subject := ""
+		if err.Explore.Object != nil {
+			subject = transformerError_join(err.Explore.Object, err.Explore.Property)
+		}
+		middle := ""
+		if err.Explore.Parameter != nil {
+			middle = "(parameter: " + transformerError_json(err.Explore.Parameter) + ")"
+		} else if err.Explore.Output {
+			middle = "(return type)"
+		}
+		typ := err.Name
+		if subject != "" {
+			typ = subject + ": " + typ
+		}
+		messages := make([]string, 0, len(err.Messages))
+		for _, msg := range err.Messages {
+			messages = append(messages, "  - "+msg)
+		}
+		lines = append(lines, "- "+typ+middle+"\n"+strings.Join(messages, "\n"))
+	}
+	return NewTransformerError(TransformerError_IProps{
+		Code:    props.Code,
+		Message: "unsupported type detected\n\n" + strings.Join(lines, "\n\n"),
+	})
+}
+
+func transformerError_join(object *nativemetadata.MetadataObjectType, key any) string {
+	if key == nil {
+		return object.Name
+	}
+	if _, ok := key.(map[string]any); ok {
+		return object.Name + "[key]"
+	}
+	if str, ok := key.(string); ok {
+		if transformerError_variable(str) {
+			return object.Name + "." + str
+		}
+		return object.Name + "[" + transformerError_json(str) + "]"
+	}
+	return object.Name + "[key]"
+}
+
+func transformerError_variable(str string) bool {
+	if str == "" {
+		return false
+	}
+	for i, ch := range str {
+		if i == 0 {
+			if ('A' <= ch && ch <= 'Z') || ('a' <= ch && ch <= 'z') || ch == '_' || ch == '$' {
+				continue
+			}
+			return false
+		}
+		if ('A' <= ch && ch <= 'Z') || ('a' <= ch && ch <= 'z') || ('0' <= ch && ch <= '9') || ch == '_' || ch == '$' {
+			continue
+		}
+		return false
+	}
+	return true
+}
+
+func transformerError_json(value any) string {
+	data, err := json.Marshal(value)
+	if err != nil {
+		return "null"
+	}
+	return string(data)
+}

package/native/core/context/index.go

@@ -0,0 +1 @@
+package context

package/native/core/factories/CommentFactory.go

@@ -0,0 +1,27 @@
+package factories
+
+import (
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+)
+
+type commentFactoryNamespace struct{}
+
+var CommentFactory = commentFactoryNamespace{}
+
+type CommentFactory_SymbolDisplayPart struct {
+	Text string
+}
+
+func (commentFactoryNamespace) Description(symbol *shimast.Symbol, includeTags ...bool) *string {
+	return nil
+}
+
+func (commentFactoryNamespace) Merge(comments []CommentFactory_SymbolDisplayPart) string {
+	builder := strings.Builder{}
+	for _, part := range comments {
+		builder.WriteString(strings.ReplaceAll(part.Text, "\r\n", "\n"))
+	}
+	return builder.String()
+}

package/native/core/factories/ExpressionFactory.go

@@ -0,0 +1,334 @@
+package factories
+
+import (
+	"crypto/rand"
+	"fmt"
+	"math"
+	"os"
+	"path/filepath"
+	"strings"
+
+	shimast "github.com/microsoft/typescript-go/shim/ast"
+	shimcore "github.com/microsoft/typescript-go/shim/core"
+	shimparser "github.com/microsoft/typescript-go/shim/parser"
+)
+
+type expressionFactoryNamespace struct{}
+
+var ExpressionFactory = expressionFactoryNamespace{}
+
+type ExpressionFactory_IsObjectProps struct {
+	CheckNull  bool
+	CheckArray bool
+	Input      *shimast.Expression
+}
+
+type ExpressionFactory_CurryingProps struct {
+	Function  *shimast.Expression
+	Arguments []*shimast.Expression
+}
+
+type ExpressionFactory_TranspileProps struct {
+	Transformer any
+	Importer    ExpressionFactory_Importer
+	Script      string
+}
+
+type ExpressionFactory_Importer interface {
+	Internal(name string) *shimast.Node
+	Instance(props ExpressionFactory_IInstance) *shimast.Node
+	Namespace(props ExpressionFactory_INamespace) *shimast.Node
+	Default(props ExpressionFactory_IDefault) *shimast.Node
+}
+
+type ExpressionFactory_IDefault struct {
+	File string
+	Name string
+	Type bool
+}
+
+type ExpressionFactory_IInstance struct {
+	File  string
+	Name  string
+	Alias *string
+}
+
+type ExpressionFactory_INamespace struct {
+	File string
+	Name string
+}
+
+type ExpressionFactory_GetEscapedTextProps struct {
+	Printer any
+	Input   *shimast.Expression
+}
+
+var expressionFactory_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+
+func (expressionFactoryNamespace) Number(value any) *shimast.Node {
+	text, numeric := expressionFactory_number_text(value)
+	if numeric < 0 {
+		return expressionFactory_factory.NewPrefixUnaryExpression(
+			shimast.KindMinusToken,
+			expressionFactory_factory.NewNumericLiteral(expressionFactory_number_abs_text(numeric), shimast.TokenFlagsNone),
+		)
+	}
+	return expressionFactory_factory.NewNumericLiteral(text, shimast.TokenFlagsNone)
+}
+
+func (expressionFactoryNamespace) Bigint(value any) *shimast.Node {
+	return expressionFactory_factory.NewCallExpression(
+		expressionFactory_factory.NewIdentifier("BigInt"),
+		nil,
+		nil,
+		expressionFactory_factory.NewNodeList([]*shimast.Node{
+			expressionFactory_factory.NewIdentifier(fmt.Sprint(value)),
+		}),
+		shimast.NodeFlagsNone,
+	)
+}
+
+func (expressionFactoryNamespace) IsRequired(input *shimast.Expression) *shimast.Node {
+	return expressionFactory_factory.NewBinaryExpression(
+		nil,
+		expressionFactory_factory.NewIdentifier("undefined"),
+		nil,
+		expressionFactory_factory.NewToken(shimast.KindExclamationEqualsEqualsToken),
+		input,
+	)
+}
+
+func (expressionFactoryNamespace) IsArray(input *shimast.Expression) *shimast.Node {
+	return expressionFactory_factory.NewCallExpression(
+		expressionFactory_factory.NewIdentifier("Array.isArray"),
+		nil,
+		nil,
+		expressionFactory_factory.NewNodeList([]*shimast.Node{input}),
+		shimast.NodeFlagsNone,
+	)
+}
+
+func (expressionFactoryNamespace) IsObject(props ExpressionFactory_IsObjectProps) *shimast.Node {
+	conditions := []*shimast.Node{
+		expressionFactory_factory.NewBinaryExpression(
+			nil,
+			expressionFactory_factory.NewStringLiteral("object", shimast.TokenFlagsNone),
+			nil,
+			expressionFactory_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
+			expressionFactory_factory.NewTypeOfExpression(props.Input),
+		),
+	}
+	if props.CheckNull {
+		conditions = append(conditions, expressionFactory_factory.NewBinaryExpression(
+			nil,
+			expressionFactory_factory.NewKeywordExpression(shimast.KindNullKeyword),
+			nil,
+			expressionFactory_factory.NewToken(shimast.KindExclamationEqualsEqualsToken),
+			props.Input,
+		))
+	}
+	if props.CheckArray {
+		conditions = append(conditions, expressionFactory_factory.NewBinaryExpression(
+			nil,
+			expressionFactory_factory.NewKeywordExpression(shimast.KindFalseKeyword),
+			nil,
+			expressionFactory_factory.NewToken(shimast.KindEqualsEqualsEqualsToken),
+			ExpressionFactory.IsArray(props.Input),
+		))
+	}
+	if len(conditions) == 1 {
+		return conditions[0]
+	}
+	output := conditions[0]
+	for _, condition := range conditions[1:] {
+		output = expressionFactory_factory.NewBinaryExpression(
+			nil,
+			output,
+			nil,
+			expressionFactory_factory.NewToken(shimast.KindAmpersandAmpersandToken),
+			condition,
+		)
+	}
+	return output
+}
+
+func (expressionFactoryNamespace) IsInstanceOf(t string, input *shimast.Expression) *shimast.Node {
+	return expressionFactory_factory.NewBinaryExpression(
+		nil,
+		input,
+		nil,
+		expressionFactory_factory.NewToken(shimast.KindInstanceOfKeyword),
+		expressionFactory_factory.NewIdentifier(t),
+	)
+}
+
+func (expressionFactoryNamespace) Coalesce(x *shimast.Expression, y *shimast.Expression) *shimast.Node {
+	return expressionFactory_factory.NewBinaryExpression(
+		nil,
+		x,
+		nil,
+		expressionFactory_factory.NewToken(shimast.KindQuestionQuestionToken),
+		y,
+	)
+}
+
+func (expressionFactoryNamespace) Currying(props ExpressionFactory_CurryingProps) *shimast.Node {
+	if len(props.Arguments) == 0 {
+		return expressionFactory_factory.NewCallExpression(props.Function, nil, nil, nil, shimast.NodeFlagsNone)
+	}
+	prev := expressionFactory_factory.NewCallExpression(
+		props.Function,
+		nil,
+		nil,
+		expressionFactory_factory.NewNodeList([]*shimast.Node{props.Arguments[0]}),
+		shimast.NodeFlagsNone,
+	)
+	for _, param := range props.Arguments[1:] {
+		prev = expressionFactory_factory.NewCallExpression(
+			prev,
+			nil,
+			nil,
+			expressionFactory_factory.NewNodeList([]*shimast.Node{param}),
+			shimast.NodeFlagsNone,
+		)
+	}
+	return prev
+}
+
+func (expressionFactoryNamespace) SelfCall(body *shimast.ConciseBody, typeNode ...*shimast.TypeNode) *shimast.Node {
+	if body != nil && body.Kind == shimast.KindCallExpression {
+		return body
+	}
+	var output *shimast.TypeNode
+	if len(typeNode) != 0 {
+		output = typeNode[0]
+	}
+	arrow := expressionFactory_factory.NewArrowFunction(
+		nil,
+		nil,
+		expressionFactory_factory.NewNodeList(nil),
+		output,
+		nil,
+		expressionFactory_factory.NewToken(shimast.KindEqualsGreaterThanToken),
+		body,
+	)
+	return expressionFactory_factory.NewCallExpression(
+		expressionFactory_factory.NewParenthesizedExpression(arrow),
+		nil,
+		nil,
+		nil,
+		shimast.NodeFlagsNone,
+	)
+}
+
+func (expressionFactoryNamespace) GetEscapedText(props ExpressionFactory_GetEscapedTextProps) string {
+	if props.Input == nil {
+		return ""
+	}
+	if props.Input.Kind == shimast.KindIdentifier || shimast.IsStringLiteral(props.Input) {
+		return props.Input.Text()
+	}
+	return IdentifierFactory.GetName(props.Input)
+}
+
+func (expressionFactoryNamespace) Transpile(props ExpressionFactory_TranspileProps) func(input *shimast.Expression) *shimast.Node {
+	file := shimparser.ParseSourceFile(
+		shimast.SourceFileParseOptions{FileName: filepath.Join(os.TempDir(), expressionFactory_random_format_uuid()+".ts")},
+		props.Script,
+		shimcore.ScriptKindTS,
+	)
+	if file == nil || file.Statements == nil || len(file.Statements.Nodes) == 0 {
+		panic("Error on ExpressionFactory.transpile(): no statement exists.")
+	}
+	statement := file.Statements.Nodes[0]
+	if statement.Kind != shimast.KindExpressionStatement {
+		panic("Error on ExpressionFactory.transpile(): statement is not an expression statement.")
+	}
+	expression := expressionFactory_factory.DeepCloneNode(statement.AsExpressionStatement().Expression)
+	return func(input *shimast.Expression) *shimast.Node {
+		var visitor *shimast.NodeVisitor
+		visitor = shimast.NewNodeVisitor(func(node *shimast.Node) *shimast.Node {
+			if node == nil {
+				return nil
+			}
+			if node.Kind == shimast.KindIdentifier && node.Text() == "$input" {
+				return input
+			}
+			if props.Importer != nil && node.Kind == shimast.KindCallExpression {
+				if imported := expressionFactory_import(props.Importer, node); imported != nil {
+					return imported
+				}
+			}
+			return node.VisitEachChild(visitor)
+		}, expressionFactory_factory, shimast.NodeVisitorHooks{})
+		return visitor.VisitNode(expression)
+	}
+}
+
+func expressionFactory_import(importer ExpressionFactory_Importer, node *shimast.Node) *shimast.Node {
+	call := node.AsCallExpression()
+	if call == nil || call.Expression == nil || call.Expression.Kind != shimast.KindIdentifier {
+		return nil
+	}
+	name := call.Expression.Text()
+	args := []*shimast.Node{}
+	if call.Arguments != nil {
+		args = call.Arguments.Nodes
+	}
+	if name == "$importInternal" && len(args) == 1 && shimast.IsStringLiteral(args[0]) {
+		return importer.Internal(args[0].Text())
+	}
+	if name == "$importInstance" && len(args) == 2 && shimast.IsStringLiteral(args[0]) && shimast.IsStringLiteral(args[1]) {
+		return importer.Instance(ExpressionFactory_IInstance{
+			Name: args[0].Text(),
+			File: args[1].Text(),
+		})
+	}
+	if name == "$importNamespace" && len(args) == 2 && shimast.IsStringLiteral(args[0]) && shimast.IsStringLiteral(args[1]) {
+		return importer.Namespace(ExpressionFactory_INamespace{
+			Name: args[0].Text(),
+			File: args[1].Text(),
+		})
+	}
+	if name == "$importDefault" && len(args) == 3 && shimast.IsStringLiteral(args[0]) && shimast.IsStringLiteral(args[1]) {
+		return importer.Default(ExpressionFactory_IDefault{
+			Name: args[0].Text(),
+			File: args[1].Text(),
+			Type: false,
+		})
+	}
+	return nil
+}
+
+func expressionFactory_number_text(value any) (string, float64) {
+	switch v := value.(type) {
+	case int:
+		return fmt.Sprint(v), float64(v)
+	case int64:
+		return fmt.Sprint(v), float64(v)
+	case float32:
+		return fmt.Sprint(v), float64(v)
+	case float64:
+		return fmt.Sprint(v), v
+	default:
+		text := fmt.Sprint(value)
+		var f float64
+		fmt.Sscan(text, &f)
+		return text, f
+	}
+}
+
+func expressionFactory_number_abs_text(value float64) string {
+	text := fmt.Sprint(math.Abs(value))
+	return strings.TrimSuffix(text, ".0")
+}
+
+func expressionFactory_random_format_uuid() string {
+	bytes := make([]byte, 16)
+	if _, err := rand.Read(bytes); err != nil {
+		return "00000000-0000-4000-8000-000000000000"
+	}
+	bytes[6] = (bytes[6] & 0x0f) | 0x40
+	bytes[8] = (bytes[8] & 0x3f) | 0x80
+	return fmt.Sprintf("%08x-%04x-%04x-%04x-%012x", bytes[0:4], bytes[4:6], bytes[6:8], bytes[8:10], bytes[10:16])
+}

package/native/core/factories/FormatCheatSheet.go

@@ -0,0 +1,30 @@
+package factories
+
+func formatCheatSheet_RegexCall(text string) string {
+	return text + ".test($input)"
+}
+
+var FormatCheatSheet = map[string]string{
+	"byte":                  "/^(?:[A-Za-z0-9+/]{4})*(?:[A-Za-z0-9+/]{2}==|[A-Za-z0-9+/]{3}=)?$/gm.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)",
+	"email":                 "/^[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*@(?:[a-z0-9](?:[a-z0-9-]*[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/i.test($input)",
+	"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)",
+	"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)",
+	"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-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]))|(?:(?:[a-z0-9\\u{00a1}-\\u{ffff}]+-)*[a-z0-9\\u{00a1}-\\u{ffff}]+)(?:\\.(?:[a-z0-9\\u{00a1}-\\u{ffff}]+-)*[a-z0-9\\u{00a1}-\\u{ffff}]+)*(?:\\.(?:[a-z\\u{00a1}-\\u{ffff}]{2,})))(?::\\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)",
+	"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)",
+	"relative-json-pointer": "/^(?:0|[1-9][0-9]*)(?:#|(?:\\/(?:[^~/]|~0|~1)*)*)$/.test($input)",
+}

package/native/core/factories/IdentifierFactory.go

@@ -0,0 +1,163 @@
+package factories
+
+import (
+	"strconv"
+	"strings"
+)
+
+import shimast "github.com/microsoft/typescript-go/shim/ast"
+
+type identifierFactoryNamespace struct{}
+
+var IdentifierFactory = identifierFactoryNamespace{}
+
+var identifierFactory_factory = shimast.NewNodeFactory(shimast.NodeFactoryHooks{})
+
+func (identifierFactoryNamespace) Identifier(name string) *shimast.Node {
+	if identifierFactory_variable(name) {
+		return identifierFactory_factory.NewIdentifier(name)
+	}
+	return identifierFactory_factory.NewStringLiteral(name, shimast.TokenFlagsNone)
+}
+
+func (identifierFactoryNamespace) Access(input *shimast.Expression, key string, chain ...bool) *shimast.Node {
+	postfix := IdentifierFactory.Identifier(key)
+	optional := len(chain) != 0 && chain[0]
+	var questionDot *shimast.QuestionDotToken
+	flags := shimast.NodeFlagsNone
+	if optional {
+		questionDot = identifierFactory_factory.NewToken(shimast.KindQuestionDotToken)
+		flags = shimast.NodeFlagsOptionalChain
+	}
+	if shimast.IsStringLiteral(postfix) {
+		return identifierFactory_factory.NewElementAccessExpression(
+			input,
+			questionDot,
+			postfix,
+			flags,
+		)
+	}
+	return identifierFactory_factory.NewPropertyAccessExpression(
+		input,
+		questionDot,
+		postfix,
+		flags,
+	)
+}
+
+func (identifierFactoryNamespace) GetName(input *shimast.Expression) string {
+	if input == nil {
+		return "unknown"
+	}
+	if shimast.IsPropertyAccessExpression(input) {
+		access := input.AsPropertyAccessExpression()
+		return IdentifierFactory.GetName(access.Expression) + "." + access.Name().Text()
+	}
+	if shimast.IsElementAccessExpression(input) {
+		access := input.AsElementAccessExpression()
+		return IdentifierFactory.GetName(access.Expression) + "[" + IdentifierFactory.GetName(access.ArgumentExpression) + "]"
+	}
+	if input.Kind == shimast.KindIdentifier || shimast.IsStringLiteral(input) {
+		return input.Text()
+	}
+	return "unknown"
+}
+
+func (identifierFactoryNamespace) Postfix(str string) string {
+	if identifierFactory_variable(str) {
+		return "\"." + str + "\""
+	}
+	quoted := strings.ReplaceAll(strconv.Quote(str), "\"", "\\\"")
+	return "\"[" + quoted + "]\""
+}
+
+func (identifierFactoryNamespace) Parameter(name any, typeNode *shimast.TypeNode, init *shimast.Node) *shimast.Node {
+	var binding *shimast.BindingName
+	switch v := name.(type) {
+	case string:
+		binding = identifierFactory_factory.NewIdentifier(v)
+	case *shimast.Node:
+		binding = v
+	default:
+		binding = identifierFactory_factory.NewIdentifier("input")
+	}
+	if typeNode == nil {
+		typeNode = TypeFactory.Keyword("any")
+	}
+	var question *shimast.QuestionToken
+	var initializer *shimast.Expression
+	if init != nil && init.Kind == shimast.KindQuestionToken {
+		question = identifierFactory_factory.NewToken(shimast.KindQuestionToken)
+	} else {
+		initializer = init
+	}
+	return identifierFactory_factory.NewParameterDeclaration(
+		nil,
+		nil,
+		binding,
+		question,
+		typeNode,
+		initializer,
+	)
+}
+
+func identifierFactory_variable(str string) bool {
+	if identifierFactory_reserved[str] || len(str) == 0 {
+		return false
+	}
+	for i := 0; i < len(str); i++ {
+		c := str[i]
+		if i == 0 {
+			if !(('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || c == '_' || c == '$') {
+				return false
+			}
+		} else if !(('a' <= c && c <= 'z') || ('A' <= c && c <= 'Z') || ('0' <= c && c <= '9') || c == '_' || c == '$') {
+			return false
+		}
+	}
+	return true
+}
+
+var identifierFactory_reserved = map[string]bool{
+	"break":      true,
+	"case":       true,
+	"catch":      true,
+	"class":      true,
+	"const":      true,
+	"continue":   true,
+	"debugger":   true,
+	"default":    true,
+	"delete":     true,
+	"do":         true,
+	"else":       true,
+	"enum":       true,
+	"export":     true,
+	"extends":    true,
+	"false":      true,
+	"finally":    true,
+	"for":        true,
+	"function":   true,
+	"if":         true,
+	"import":     true,
+	"in":         true,
+	"instanceof": true,
+	"module":     true,
+	"new":        true,
+	"null":       true,
+	"package":    true,
+	"public":     true,
+	"private":    true,
+	"protected":  true,
+	"return":     true,
+	"super":      true,
+	"switch":     true,
+	"this":       true,
+	"throw":      true,
+	"true":       true,
+	"try":        true,
+	"typeof":     true,
+	"var":        true,
+	"void":       true,
+	"while":      true,
+	"with":       true,
+}