json5-parser 0.0.0

GrammarInfo {
    url: None,
    name: Identifier("Json5", 8..13),
    extensions: [],
    imports: {},
    exports: [],
    rules: {
        "Value": GrammarRule {
            name: Identifier("Value", 57..62),
            redirect: None,
            document: "",
            derives: RuleDerive {
                derives: {},
            },
            atomic: Optimized,
            inline: false,
            viewer: GrammarViewer {
                hidden: false,
                styles: [],
                railway: true,
            },
            captures: GrammarCaptures {
                text: false,
                auto: true,
                range: "usize",
            },
            body: Union {
                branches: [
                    YggdrasilVariant {
                        tag: Some(
                            Identifier("Object", 80..86),
                        ),
                        branch: Expression {
                            tag: Identifier("Object", 80..86),
                            remark: false,
                            body: RuleReference {
                                name: Identifier("Object", 71..77),
                                boxed: false,
                                inline: false,
                            },
                        },
                    },
                    YggdrasilVariant {
                        tag: Some(
                            Identifier("Array", 102..107),
                        ),
                        branch: Expression {
                            tag: Identifier("Array", 102..107),
                            remark: false,
                            body: RuleReference {
                                name: Identifier("Array", 93..98),
                                boxed: false,
                                inline: false,
                            },
                        },
                    },
                    YggdrasilVariant {
                        tag: Some(
                            Identifier("String", 123..129),
                        ),
                        branch: Expression {
                            tag: Identifier("String", 123..129),
                            remark: false,
                            body: RuleReference {
                                name: Identifier("String", 114..120),
                                boxed: false,
                                inline: false,
                            },
                        },
                    },
                    YggdrasilVariant {
                        tag: Some(
                            Identifier("Number", 145..151),
                        ),
                        branch: Expression {
                            tag: Identifier("Number", 145..151),
                            remark: false,
                            body: RuleReference {
                                name: Identifier("Number", 136..142),
                                boxed: false,
                                inline: false,
                            },
                        },
                    },
                    YggdrasilVariant {
                        tag: Some(
                            Identifier("Boolean", 167..174),
                        ),
                        branch: Expression {
                            tag: Identifier("Boolean", 167..174),
                            remark: false,
                            body: RuleReference {
                                name: Identifier("Boolean", 158..165),
                                boxed: false,
                                inline: false,
                            },
                        },
                    },
                    YggdrasilVariant {
                        tag: Some(
                            Identifier("Null", 190..194),
                        ),
                        branch: Expression {
                            tag: Identifier("Null", 190..194),
                            remark: false,
                            body: RuleReference {
                                name: Identifier("Null", 181..185),
                                boxed: false,
                                inline: false,
                            },
                        },
                    },
                ],
            },
            range: 45..196,
        },
        "Object": GrammarRule {
            name: Identifier("Object", 204..210),
            redirect: None,
            document: "",
            derives: RuleDerive {
                derives: {},
            },
            atomic: Optimized,
            inline: false,
            viewer: GrammarViewer {
                hidden: false,
                styles: [],
                railway: true,
            },
            captures: GrammarCaptures {
                text: false,
                auto: true,
                range: "usize",
            },
            body: Class {
                term: Expression {
                    tag: None,
                    remark: false,
                    body: ConcatExpression {
                        sequence: [
                            Expression {
                                tag: None,
                                remark: false,
                                body: YggdrasilText {
                                    text: "{",
                                    insensitive: false,
                                    range: 217..220,
                                },
                            },
                            Expression {
                                tag: None,
                                remark: false,
                                body: HIDE,
                            },
                            Expression {
                                tag: None,
                                remark: false,
                                body: UnaryExpression {
                                    base: Expression {
                                        tag: None,
                                        remark: false,
                                        body: ConcatExpression {
                                            sequence: [
                                                Expression {
                                                    tag: Identifier("ObjectPair", 222..232),
                                                    remark: false,
                                                    body: RuleReference {
                                                        name: Identifier("ObjectPair", 222..232),
                                                        boxed: false,
                                                        inline: false,
                                                    },
                                                },
                                                Expression {
                                                    tag: None,
                                                    remark: false,
                                                    body: HIDE,
                                                },
                                                Expression {
                                                    tag: None,
                                                    remark: false,
                                                    body: UnaryExpression {
                                                        base: Expression {
                                                            tag: None,
                                                            remark: false,
                                                            body: ConcatExpression {
                                                                sequence: [
                                                                    Expression {
                                                                        tag: None,
                                                                        remark: false,
                                                                        body: HIDE,
                                                                    },
                                                                    Expression {
                                                                        tag: None,
                                                                        remark: false,
                                                                        body: ConcatExpression {
                                                                            sequence: [
                                                                                Expression {
                                                                                    tag: Identifier("COMMA", 234..239),
                                                                                    remark: false,
                                                                                    body: RuleReference {
                                                                                        name: Identifier("COMMA", 234..239),
                                                                                        boxed: false,
                                                                                        inline: false,
                                                                                    },
                                                                                },
                                                                                Expression {
                                                                                    tag: None,
                                                                                    remark: false,
                                                                                    body: HIDE,
                                                                                },
                                                                                Expression {
                                                                                    tag: Identifier("ObjectPair", 240..250),
                                                                                    remark: false,
                                                                                    body: RuleReference {
                                                                                        name: Identifier("ObjectPair", 240..250),
                                                                                        boxed: false,
                                                                                        inline: false,
                                                                                    },
                                                                                },
                                                                            ],
                                                                        },
                                                                    },
                                                                ],
                                                            },
                                                        },
                                                        operators: [
                                                            RepeatsBetween(
                                                                YggdrasilCounter {
                                                                    min: 0,
                                                                    max: 4294967295,
                                                                },
                                                            ),
                                                        ],
                                                    },
                                                },
                                                Expression {
                                                    tag: None,
                                                    remark: false,
                                                    body: HIDE,
                                                },
                                                Expression {
                                                    tag: Identifier("COMMA", 253..258),
                                                    remark: false,
                                                    body: RuleReference {
                                                        name: Identifier("COMMA", 253..258),
                                                        boxed: false,
                                                        inline: false,
                                                    },
                                                },
                                            ],
                                        },
                                    },
                                    operators: [
                                        RepeatsBetween(
                                            YggdrasilCounter {
                                                min: 0,
                                                max: 1,
                                            },
                                        ),
                                    ],
                                },
                            },
                            Expression {
                                tag: None,
                                remark: false,
                                body: HIDE,
                            },
                            Expression {
                                tag: None,
                                remark: false,
                                body: YggdrasilText {
                                    text: "}",
                                    insensitive: false,
                                    range: 261..264,
                                },
                            },
                        ],
                    },
                },
            },
            range: 198..266,
        },
        "ObjectPair": GrammarRule {
            name: Identifier("ObjectPair", 274..284),
            redirect: None,
            document: "",
            derives: RuleDerive {
                derives: {},
            },
            atomic: Optimized,
            inline: false,
            viewer: GrammarViewer {
                hidden: false,
                styles: [],
                railway: true,
            },
            captures: GrammarCaptures {
                text: false,
                auto: true,
                range: "usize",
            },
            body: Class {
                term: Expression {
                    tag: None,
                    remark: false,
                    body: ConcatExpression {
                        sequence: [
                            Expression {
                                tag: Identifier("ObjectKey", 291..300),
                                remark: false,
                                body: RuleReference {
                                    name: Identifier("ObjectKey", 291..300),
                                    boxed: false,
                                    inline: false,
                                },
                            },
                            Expression {
                                tag: None,
                                remark: false,
                                body: HIDE,
                            },
                            Expression {
                                tag: Identifier("COLON", 301..306),
                                remark: false,
                                body: RuleReference {
                                    name: Identifier("COLON", 301..306),
                                    boxed: false,
                                    inline: false,
                                },
                            },
                            Expression {
                                tag: None,
                                remark: false,
                                body: HIDE,
                            },
                            Expression {
                                tag: Identifier("Value", 307..312),
                                remark: false,
                                body: RuleReference {
                                    name: Identifier("Value", 307..312),
                                    boxed: false,
                                    inline: false,
                                },
                            },
                        ],
                    },
                },
            },
            range: 268..314,
        },
        "ObjectKey": GrammarRule {
            name: Identifier("ObjectKey", 322..331),
            redirect: None,
            document: "",
            derives: RuleDerive {
                derives: {},
            },
            atomic: Optimized,
            inline: false,
            viewer: GrammarViewer {
                hidden: false,
                styles: [],
                railway: true,
            },
            captures: GrammarCaptures {
                text: false,
                auto: true,
                range: "usize",
            },
            body: Union {
                branches: [
                    YggdrasilVariant {
                        tag: Some(
                            Identifier("Identifier", 340..350),
                        ),
                        branch: Expression {
                            tag: Identifier("Identifier", 340..350),
                            remark: false,
                            body: RuleReference {
                                name: Identifier("Identifier", 340..350),
                                boxed: false,
                                inline: false,
                            },
                        },
                    },
                    YggdrasilVariant {
                        tag: Some(
                            Identifier("String", 357..363),
                        ),
                        branch: Expression {
                            tag: Identifier("String", 357..363),
                            remark: false,
                            body: RuleReference {
                                name: Identifier("String", 357..363),
                                boxed: false,
                                inline: false,
                            },
                        },
                    },
                ],
            },
            range: 316..365,
        },
        "Array": GrammarRule {
            name: Identifier("Array", 373..378),
            redirect: None,
            document: "",
            derives: RuleDerive {
                derives: {},
            },
            atomic: Optimized,
            inline: false,
            viewer: GrammarViewer {
                hidden: false,
                styles: [],
                railway: true,
            },
            captures: GrammarCaptures {
                text: false,
                auto: true,
                range: "usize",
            },
            body: Class {
                term: Expression {
                    tag: None,
                    remark: false,
                    body: ConcatExpression {
                        sequence: [
                            Expression {
                                tag: None,
                                remark: false,
                                body: YggdrasilText {
                                    text: "[",
                                    insensitive: false,
                                    range: 385..388,
                                },
                            },
                            Expression {
                                tag: None,
                                remark: false,
                                body: HIDE,
                            },
                            Expression {
                                tag: None,
                                remark: false,
                                body: UnaryExpression {
                                    base: Expression {
                                        tag: None,
                                        remark: false,
                                        body: ConcatExpression {
                                            sequence: [
                                                Expression {
                                                    tag: Identifier("Value", 390..395),
                                                    remark: false,
                                                    body: RuleReference {
                                                        name: Identifier("Value", 390..395),
                                                        boxed: false,
                                                        inline: false,
                                                    },
                                                },
                                                Expression {
                                                    tag: None,
                                                    remark: false,
                                                    body: HIDE,
                                                },
                                                Expression {
                                                    tag: None,
                                                    remark: false,
                                                    body: UnaryExpression {
                                                        base: Expression {
                                                            tag: None,
                                                            remark: false,
                                                            body: ConcatExpression {
                                                                sequence: [
                                                                    Expression {
                                                                        tag: None,
                                                                        remark: false,
                                                                        body: HIDE,
                                                                    },
                                                                    Expression {
                                                                        tag: None,
                                                                        remark: false,
                                                                        body: ConcatExpression {
                                                                            sequence: [
                                                                                Expression {
                                                                                    tag: Identifier("COMMA", 397..402),
                                                                                    remark: false,
                                                                                    body: RuleReference {
                                                                                        name: Identifier("COMMA", 397..402),
                                                                                        boxed: false,
                                                                                        inline: false,
                                                                                    },
                                                                                },
                                                                                Expression {
                                                                                    tag: None,
                                                                                    remark: false,
                                                                                    body: HIDE,
                                                                                },
                                                                                Expression {
                                                                                    tag: Identifier("Value", 403..408),
                                                                                    remark: false,
                                                                                    body: RuleReference {
                                                                                        name: Identifier("Value", 403..408),
                                                                                        boxed: false,
                                                                                        inline: false,
                                                                                    },
                                                                                },
                                                                            ],
                                                                        },
                                                                    },
                                                                ],
                                                            },
                                                        },
                                                        operators: [
                                                            RepeatsBetween(
                                                                YggdrasilCounter {
                                                                    min: 0,
                                                                    max: 4294967295,
                                                                },
                                                            ),
                                                        ],
                                                    },
                                                },
                                                Expression {
                                                    tag: None,
                                                    remark: false,
                                                    body: HIDE,
                                                },
                                                Expression {
                                                    tag: Identifier("COMMA", 411..416),
                                                    remark: false,
                                                    body: RuleReference {
                                                        name: Identifier("COMMA", 411..416),
                                                        boxed: false,
                                                        inline: false,
                                                    },
                                                },
                                            ],
                                        },
                                    },
                                    operators: [
                                        RepeatsBetween(
                                            YggdrasilCounter {
                                                min: 0,
                                                max: 1,
                                            },
                                        ),
                                    ],
                                },
                            },
                            Expression {
                                tag: None,
                                remark: false,
                                body: HIDE,
                            },
                            Expression {
                                tag: None,
                                remark: false,
                                body: YggdrasilText {
                                    text: "]",
                                    insensitive: false,
                                    range: 419..422,
                                },
                            },
                        ],
                    },
                },
            },
            range: 367..424,
        },
        "String": GrammarRule {
            name: Identifier("String", 439..445),
            redirect: None,
            document: "",
            derives: RuleDerive {
                derives: {},
            },
            atomic: Optimized,
            inline: false,
            viewer: GrammarViewer {
                hidden: false,
                styles: [],
                railway: true,
            },
            captures: GrammarCaptures {
                text: false,
                auto: true,
                range: "usize",
            },
            body: Class {
                term: Expression {
                    tag: None,
                    remark: false,
                    body: ChoiceExpression {
                        branches: [
                            Expression {
                                tag: None,
                                remark: false,
                                body: ConcatExpression {
                                    sequence: [
                                        Expression {
                                            tag: None,
                                            remark: false,
                                            body: YggdrasilText {
                                                text: "\"",
                                                insensitive: false,
                                                range: 454..457,
                                            },
                                        },
                                        Expression {
                                            tag: None,
                                            remark: false,
                                            body: UnaryExpression {
                                                base: Expression {
                                                    tag: Identifier("StringElement", 458..471),
                                                    remark: false,
                                                    body: RuleReference {
                                                        name: Identifier("StringElement", 458..471),
                                                        boxed: false,
                                                        inline: false,
                                                    },
                                                },
                                                operators: [
                                                    RepeatsBetween(
                                                        YggdrasilCounter {
                                                            min: 0,
                                                            max: 4294967295,
                                                        },
                                                    ),
                                                ],
                                            },
                                        },
                                        Expression {
                                            tag: None,
                                            remark: false,
                                            body: YggdrasilText {
                                                text: "\"",
                                                insensitive: false,
                                                range: 473..476,
                                            },
                                        },
                                    ],
                                },
                            },
                            Expression {
                                tag: None,
                                remark: false,
                                body: ConcatExpression {
                                    sequence: [
                                        Expression {
                                            tag: None,
                                            remark: false,
                                            body: YggdrasilText {
                                                text: "'",
                                                insensitive: false,
                                                range: 483..486,
                                            },
                                        },
                                        Expression {
                                            tag: None,
                                            remark: false,
                                            body: UnaryExpression {
                                                base: Expression {
                                                    tag: Identifier("StringElement", 487..500),
                                                    remark: false,
                                                    body: RuleReference {
                                                        name: Identifier("StringElement", 487..500),
                                                        boxed: false,
                                                        inline: false,
                                                    },
                                                },
                                                operators: [
                                                    RepeatsBetween(
                                                        YggdrasilCounter {
                                                            min: 0,
                                                            max: 4294967295,
                                                        },
                                                    ),
                                                ],
                                            },
                                        },
                                        Expression {
                                            tag: None,
                                            remark: false,
                                            body: YggdrasilText {
                                                text: "'",
                                                insensitive: false,
                                                range: 502..505,
                                            },
                                        },
                                    ],
                                },
                            },
                        ],
                    },
                },
            },
            range: 426..507,
        },
        "StringElement": GrammarRule {
            name: Identifier("StringElement", 522..535),
            redirect: None,
            document: "",
            derives: RuleDerive {
                derives: {},
            },
            atomic: Optimized,
            inline: false,
            viewer: GrammarViewer {
                hidden: false,
                styles: [],
                railway: true,
            },
            captures: GrammarCaptures {
                text: false,
                auto: true,
                range: "usize",
            },
            body: Union {
                branches: [
                    YggdrasilVariant {
                        tag: Some(
                            Identifier("HexDigit", 558..566),
                        ),
                        branch: Expression {
                            tag: Identifier("HexDigit", 558..566),
                            remark: false,
                            body: ConcatExpression {
                                sequence: [
                                    Expression {
                                        tag: None,
                                        remark: false,
                                        body: YggdrasilText {
                                            text: "\\",
                                            insensitive: false,
                                            range: 544..547,
                                        },
                                    },
                                    Expression {
                                        tag: Identifier("HexDigit", 548..556),
                                        remark: false,
                                        body: RuleReference {
                                            name: Identifier("HexDigit", 548..556),
                                            boxed: false,
                                            inline: false,
                                        },
                                    },
                                ],
                            },
                        },
                    },
                    YggdrasilVariant {
                        tag: Some(
                            Identifier("Escaped", 587..594),
                        ),
                        branch: Expression {
                            tag: Identifier("Escaped", 587..594),
                            remark: false,
                            body: ConcatExpression {
                                sequence: [
                                    Expression {
                                        tag: None,
                                        remark: false,
                                        body: YggdrasilText {
                                            text: "\\",
                                            insensitive: false,
                                            range: 573..576,
                                        },
                                    },
                                    Expression {
                                        tag: Identifier("Escaped", 577..584),
                                        remark: false,
                                        body: RuleReference {
                                            name: Identifier("Escaped", 577..584),
                                            boxed: false,
                                            inline: false,
                                        },
                                    },
                                ],
                            },
                        },
                    },
                    YggdrasilVariant {
                        tag: Some(
                            Identifier("StringText", 615..625),
                        ),
                        branch: Expression {
                            tag: Identifier("StringText", 615..625),
                            remark: false,
                            body: RuleReference {
                                name: Identifier("StringText", 601..611),
                                boxed: false,
                                inline: false,
                            },
                        },
                    },
                ],
            },
            range: 509..627,
        },
        "HexDigit": GrammarRule {
            name: Identifier("HexDigit", 641..649),
            redirect: None,
            document: "",
            derives: RuleDerive {
                derives: {},
            },
            atomic: Optimized,
            inline: false,
            viewer: GrammarViewer {
                hidden: false,
                styles: [],
                railway: true,
            },
            captures: GrammarCaptures {
                text: true,
                auto: true,
                range: "usize",
            },
            body: Class {
                term: Expression {
                    tag: None,
                    remark: false,
                    body: YggdrasilRegex {
                        raw: "[0-9a-fA-F]{4}",
                        span: 656..672,
                    },
                },
            },
            range: 629..674,
        },
        "Escaped": GrammarRule {
            name: Identifier("Escaped", 686..693),
            redirect: None,
            document: "",
            derives: RuleDerive {
                derives: {},
            },
            atomic: Optimized,
            inline: false,
            viewer: GrammarViewer {
                hidden: false,
                styles: [],
                railway: true,
            },
            captures: GrammarCaptures {
                text: true,
                auto: true,
                range: "usize",
            },
            body: Class {
                term: Expression {
                    tag: None,
                    remark: false,
                    body: ANY,
                },
            },
            range: 675..705,
        },
        "StringText": GrammarRule {
            name: Identifier("StringText", 717..727),
            redirect: None,
            document: "",
            derives: RuleDerive {
                derives: {},
            },
            atomic: Optimized,
            inline: false,
            viewer: GrammarViewer {
                hidden: false,
                styles: [],
                railway: true,
            },
            captures: GrammarCaptures {
                text: true,
                auto: true,
                range: "usize",
            },
            body: Class {
                term: Expression {
                    tag: None,
                    remark: false,
                    body: YggdrasilRegex {
                        raw: "[^\"'\\\\]+",
                        span: 734..746,
                    },
                },
            },
            range: 706..748,
        },
        "Number": GrammarRule {
            name: Identifier("Number", 768..774),
            redirect: None,
            document: "",
            derives: RuleDerive {
                derives: {},
            },
            atomic: Optimized,
            inline: false,
            viewer: GrammarViewer {
                hidden: false,
                styles: [],
                railway: true,
            },
            captures: GrammarCaptures {
                text: true,
                auto: true,
                range: "usize",
            },
            body: Class {
                term: Expression {
                    tag: None,
                    remark: false,
                    body: YggdrasilRegex {
                        raw: "[+-]?(0|[1-9][0-9]*)",
                        span: 781..803,
                    },
                },
            },
            range: 750..805,
        },
        "Boolean": GrammarRule {
            name: Identifier("Boolean", 813..820),
            redirect: None,
            document: "",
            derives: RuleDerive {
                derives: {},
            },
            atomic: Optimized,
            inline: false,
            viewer: GrammarViewer {
                hidden: false,
                styles: [],
                railway: true,
            },
            captures: GrammarCaptures {
                text: false,
                auto: true,
                range: "usize",
            },
            body: Union {
                branches: [
                    YggdrasilVariant {
                        tag: Some(
                            Identifier("True", 838..842),
                        ),
                        branch: Expression {
                            tag: Identifier("True", 838..842),
                            remark: false,
                            body: YggdrasilText {
                                text: "true",
                                insensitive: false,
                                range: 829..835,
                            },
                        },
                    },
                    YggdrasilVariant {
                        tag: Some(
                            Identifier("False", 858..863),
                        ),
                        branch: Expression {
                            tag: Identifier("False", 858..863),
                            remark: false,
                            body: YggdrasilText {
                                text: "false",
                                insensitive: false,
                                range: 849..856,
                            },
                        },
                    },
                ],
            },
            range: 807..865,
        },
        "Null": GrammarRule {
            name: Identifier("Null", 873..877),
            redirect: None,
            document: "",
            derives: RuleDerive {
                derives: {},
            },
            atomic: Optimized,
            inline: false,
            viewer: GrammarViewer {
                hidden: false,
                styles: [],
                railway: true,
            },
            captures: GrammarCaptures {
                text: false,
                auto: true,
                range: "usize",
            },
            body: Class {
                term: Expression {
                    tag: None,
                    remark: false,
                    body: YggdrasilText {
                        text: "null",
                        insensitive: false,
                        range: 884..890,
                    },
                },
            },
            range: 867..892,
        },
        "Identifier": GrammarRule {
            name: Identifier("Identifier", 900..910),
            redirect: None,
            document: "",
            derives: RuleDerive {
                derives: {},
            },
            atomic: Optimized,
            inline: false,
            viewer: GrammarViewer {
                hidden: false,
                styles: [],
                railway: true,
            },
            captures: GrammarCaptures {
                text: false,
                auto: true,
                range: "usize",
            },
            body: Class {
                term: Expression {
                    tag: None,
                    remark: false,
                    body: YggdrasilRegex {
                        raw: "[_\\p{XID_start}][\\p{XID_continue}]*",
                        span: 917..954,
                    },
                },
            },
            range: 894..956,
        },
        "COLON": GrammarRule {
            name: Identifier("COLON", 971..976),
            redirect: None,
            document: "",
            derives: RuleDerive {
                derives: {},
            },
            atomic: Optimized,
            inline: false,
            viewer: GrammarViewer {
                hidden: false,
                styles: [],
                railway: true,
            },
            captures: GrammarCaptures {
                text: false,
                auto: false,
                range: "usize",
            },
            body: Class {
                term: Expression {
                    tag: None,
                    remark: false,
                    body: YggdrasilText {
                        text: ":",
                        insensitive: false,
                        range: 978..981,
                    },
                },
            },
            range: 971..981,
        },
        "COMMA": GrammarRule {
            name: Identifier("COMMA", 986..991),
            redirect: None,
            document: "",
            derives: RuleDerive {
                derives: {},
            },
            atomic: Optimized,
            inline: false,
            viewer: GrammarViewer {
                hidden: false,
                styles: [],
                railway: true,
            },
            captures: GrammarCaptures {
                text: false,
                auto: false,
                range: "usize",
            },
            body: Class {
                term: Expression {
                    tag: None,
                    remark: false,
                    body: YggdrasilText {
                        text: ",",
                        insensitive: false,
                        range: 993..996,
                    },
                },
            },
            range: 986..996,
        },
        "Comment": GrammarRule {
            name: Identifier("Comment", 1011..1018),
            redirect: None,
            document: "",
            derives: RuleDerive {
                derives: {},
            },
            atomic: Optimized,
            inline: false,
            viewer: GrammarViewer {
                hidden: true,
                styles: [],
                railway: true,
            },
            captures: GrammarCaptures {
                text: false,
                auto: true,
                range: "usize",
            },
            body: Class {
                term: Expression {
                    tag: None,
                    remark: false,
                    body: ConcatExpression {
                        sequence: [
                            Expression {
                                tag: None,
                                remark: false,
                                body: YggdrasilText {
                                    text: "#",
                                    insensitive: false,
                                    range: 1027..1030,
                                },
                            },
                            Expression {
                                tag: None,
                                remark: false,
                                body: REST_OF_LINE,
                            },
                        ],
                    },
                },
            },
            range: 1000..1036,
        },
        "WhiteSpace": GrammarRule {
            name: Identifier("WhiteSpace", 1049..1059),
            redirect: None,
            document: "",
            derives: RuleDerive {
                derives: {},
            },
            atomic: Optimized,
            inline: false,
            viewer: GrammarViewer {
                hidden: true,
                styles: [],
                railway: true,
            },
            captures: GrammarCaptures {
                text: false,
                auto: true,
                range: "usize",
            },
            body: Class {
                term: Expression {
                    tag: None,
                    remark: false,
                    body: ChoiceExpression {
                        branches: [
                            Expression {
                                tag: None,
                                remark: false,
                                body: YggdrasilText {
                                    text: " ",
                                    insensitive: false,
                                    range: 1093..1096,
                                },
                            },
                            Expression {
                                tag: None,
                                remark: false,
                                body: YggdrasilText {
                                    text: "\\n",
                                    insensitive: false,
                                    range: 1099..1103,
                                },
                            },
                            Expression {
                                tag: None,
                                remark: false,
                                body: YggdrasilText {
                                    text: "\\r",
                                    insensitive: false,
                                    range: 1106..1110,
                                },
                            },
                        ],
                    },
                },
            },
            range: 1038..1112,
        },
    },
    token_sets: {},
    functions: {},
}