 		// startRegex
 		case .startRegex:
 			return [
-					T.regexDelimeter._rule([RuleAnnotation.void : RuleAnnotationValue.set]),
+					"/".terminal(token: T._transient, annotations: [RuleAnnotation.void : RuleAnnotationValue.set]),
 					"*".terminal(token: T._transient).not(producing: T._transient).lookahead(),
 					"/".terminal(token: T._transient).not(producing: T._transient).lookahead(),
 					].sequence(token: T.startRegex, annotations: annotations.isEmpty ? [RuleAnnotation.void : RuleAnnotationValue.set] : annotations)
 		// endRegex
 		case .endRegex:
-			return [T.regexDelimeter._rule([RuleAnnotation.void : RuleAnnotationValue.set])].sequence(token: self)
+			return "/".terminal(token: T.endRegex, annotations: annotations.isEmpty ? [RuleAnnotation.void : RuleAnnotationValue.set] : annotations)
 		// regexBody
 		case .regexBody:
 			return [

    
    // Expression
    enum Expression : Codable {
        case element(element:Element)
        case sequence(sequence:Sequence)
        case choice(choice:Choice)
        
        enum CodingKeys : Swift.String, CodingKey {
            case element,sequence,choice
        }
        
        init(from decoder: Decoder) throws {
            let container = try decoder.container(keyedBy: CodingKeys.self)
            
            if let element = try? container.decode(Element.self, forKey: .element){
            	self = .element(element: element)
            	return
            } else if let sequence = try? container.decode(Sequence.self, forKey: .sequence){
            	self = .sequence(sequence: sequence)
            	return
            } else if let choice = try? container.decode(Choice.self, forKey: .choice){
            	self = .choice(choice: choice)
            	return
            }
            throw DecodingError.valueNotFound(Expression.self, DecodingError.Context(codingPath: decoder.codingPath, debugDescription: "Tried to decode one of Element,Sequence,Choice but found none of those types"))
        }
        func encode(to encoder:Encoder) throws {
            var container = encoder.container(keyedBy: CodingKeys.self)
            switch self {
            case .element(let element):
                try container.encode(element, forKey: .element)
            case .sequence(let sequence):
                try container.encode(sequence, forKey: .sequence)
            case .choice(let choice):
                try container.encode(choice, forKey: .choice)
            }
        }
    }
    
    /// Rule 
    struct Rule : Codable {
        let identifier: Swift.String
        let annotations: Annotations?
        let expression: Expression
        let transient: Swift.String?
        let assignmentOperators: AssignmentOperators
        let void: Swift.String?
    }
    
    /// ModuleImport 
    struct ModuleImport : Codable {
        let moduleName: Swift.String
        let `import`: Swift.String
    }
    
    typealias Modules = [ModuleImport] 

    
    /// Element 
    class Element : Codable {
        let negated: Swift.String?
        let terminal: Terminal?
        let lookahead: Swift.String?
        let annotations: Annotations?
        let void: Swift.String?
        let quantifier: Swift.String?
        let group: Group?
        let identifier: Swift.String?
        let transient: Swift.String?
    }
    
