···

       
16
       
 
       
		return s

     

       
17
       
 
       
	}

     

       
18
       
 
       


     

       
19
       
-
       
	parts := strings.SplitN(s[4:], "-", 2) // Skip "did-" prefix and split on first "-"

     

       
20
       
-
       
	if len(parts) != 2 {

     

       
21
       
-
       
		return s

     

       
22
       
-
       
	}

     

       
23
       
-
       


     

       
24
       
-
       
	return "did:" + parts[0] + ":" + parts[1]

     

       
25
       
 
       
}

     

       
26
       
 
       


     

       
27
       
 
       
// IsFlattenedDid checks if the given string is a flattened DID.

     
···

       
31
       
 
       
		return false

     

       
32
       
 
       
	}

     

       
33
       
 
       


     

       
34
       
-
       
	// Split the string to extract method and identifier

     

       
35
       
-
       
	parts := strings.SplitN(s[4:], "-", 2) // Skip "did-" prefix and split on first "-"

     

       
36
       
-
       
	if len(parts) != 2 {

     

       
37
       
-
       
		return false

     

       
38
       
-
       
	}

     

       
39
       
-
       


     

       
40
       
-
       
	// Reconstruct as a standard DID format

     

       
41
       
 
       
	// Example: "did-plc-xyz-abc" becomes "did:plc:xyz-abc"

     

       
42
       
-
       
	reconstructed := "did:" + parts[0] + ":" + parts[1]

     

       
43
       
 
       
	re := regexp.MustCompile(`^did:[a-z]+:[a-zA-Z0-9._:%-]*[a-zA-Z0-9._-]$`)

     

       
44
       
 
       


     

       
45
       
 
       
	return re.MatchString(reconstructed)

     
···

       
49
       
 
       
// A flattened DID is a DID with the :s swapped to -s to satisfy certain

     

       
50
       
 
       
// application requirements, such as Go module naming conventions.

     

       
51
       
 
       
func FlattenDid(s string) string {

     

       
52
       
-
       
	if !IsFlattenedDid(s) {

     

       
53
       
-
       
		return s

     

       
54
       
-
       
	}

     

       
55
       
-
       


     

       
56
       
-
       
	parts := strings.SplitN(s[4:], ":", 2) // Skip "did:" prefix and split on first ":"

     

       
57
       
-
       
	if len(parts) != 2 {

     

       
58
       
-
       
		return s

     

       
59
       
 
       
	}

     

       
0
       
 
       

     

       
0
       
 
       

     

       
60
       
 
       


     

       
61
       
-
       
	return "did-" + parts[0] + "-" + parts[1]

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
62
       
 
       
}

     

···

       
16
       
 
       
		return s

     

       
17
       
 
       
	}

     

       
18
       
 
       


     

       
19
       
+
       
	return strings.Replace(s, "-", ":", 2)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
20
       
 
       
}

     

       
21
       
 
       


     

       
22
       
 
       
// IsFlattenedDid checks if the given string is a flattened DID.

     
···

       
26
       
 
       
		return false

     

       
27
       
 
       
	}

     

       
28
       
 
       


     

       
29
       
+
       
	// Reconstruct as a standard DID format using Replace

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
30
       
 
       
	// Example: "did-plc-xyz-abc" becomes "did:plc:xyz-abc"

     

       
31
       
+
       
	reconstructed := strings.Replace(s, "-", ":", 2)

     

       
32
       
 
       
	re := regexp.MustCompile(`^did:[a-z]+:[a-zA-Z0-9._:%-]*[a-zA-Z0-9._-]$`)

     

       
33
       
 
       


     

       
34
       
 
       
	return re.MatchString(reconstructed)

     
···

       
38
       
 
       
// A flattened DID is a DID with the :s swapped to -s to satisfy certain

     

       
39
       
 
       
// application requirements, such as Go module naming conventions.

     

       
40
       
 
       
func FlattenDid(s string) string {

     

       
41
       
+
       
	if IsDid(s) {

     

       
42
       
+
       
		return strings.Replace(s, ":", "-", 2)

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
0
       
 
       

     

       
43
       
 
       
	}

     

       
44
       
+
       
	return s

     

       
45
       
+
       
}

     

       
46
       
 
       


     

       
47
       
+
       
// IsDid checks if the given string is a standard DID.

     

       
48
       
+
       
func IsDid(s string) bool {

     

       
49
       
+
       
	re := regexp.MustCompile(`^did:[a-z]+:[a-zA-Z0-9._:%-]*[a-zA-Z0-9._-]$`)

     

       
50
       
+
       
	return re.MatchString(s)

     

       
51
       
 
       
}