<xsl:apply-templates select="." mode="title-full"/>

<xsl:if test="@database">
                        <xsl:attribute name="data-dburl">
                            <xsl:value-of select="$external-directory"/>
                            <xsl:value-of select="@database"/>
                        </xsl:attribute>
                    </xsl:if>
                    
                    <xsl:if test="not($b-natural)">
                        <xsl:attribute name="data-language">
                            <xsl:value-of select="$active-language"/>
                        </xsl:attribute>
                    </xsl:if>
                    
                    
                    <xsl:attribute name="data-randomize">
                        <xsl:choose>
                            <xsl:when test="$b-randomize">
                                <xsl:text>true</xsl:text>
                            </xsl:when>
                            <xsl:otherwise>
                                <xsl:text>false</xsl:text>
                            </xsl:otherwise>
                        </xsl:choose>
                    </xsl:attribute>
                    
                    
                    <xsl:attribute name="data-reuse">
                        <xsl:choose>
                            <xsl:when test="$b-reuse">
                                <xsl:text>true</xsl:text>
                            </xsl:when>
                            <xsl:otherwise>
                                <xsl:text>false</xsl:text>
                            </xsl:otherwise>
                        </xsl:choose>
                    </xsl:attribute>
                    
                    
                    
                    
                    
                    
                    
                    
                    
                    <xsl:variable name="blockanswer">
                        
                        
                        <xsl:for-each select="$authored-blocks">
                            
                            <xsl:variable name="the-block" select="."/>
                            <xsl:choose>
                                
                                
                                <xsl:when test="@correct = 'no'"/>
                                
                                
                                
                                <xsl:when test="$b-randomize">
                                    <xsl:choose>
                                        
                                        <xsl:when test="@ref">
                                            <xsl:variable name="target" select="id(@ref)"/>
                                            
                                            <xsl:for-each select="$unique-blocks">
                                                <xsl:if test="count(.|$target) = 1">
                                                    <xsl:value-of select="position() - 1"/>
                                                </xsl:if>
                                            </xsl:for-each>
                                        </xsl:when>
                                        
                                        <xsl:otherwise>
                                            <xsl:for-each select="$unique-blocks">
                                                <xsl:if test="count(.|$the-block) = 1">
                                                    <xsl:value-of select="position() - 1"/>
                                                </xsl:if>
                                            </xsl:for-each>
                                        </xsl:otherwise>
                                    </xsl:choose>
                                </xsl:when>
                                
                                
                                
                                
                                
                                
                                
                                
                                <xsl:otherwise>
                                    <xsl:choose>
                                        
                                        <xsl:when test="@ref">
                                            <xsl:variable name="target" select="id(@ref)"/>
                                            
                                            <xsl:for-each select="$unique-blocks">
                                                <xsl:sort select="@order"/>
                                                <xsl:if test="count(.|$target) = 1">
                                                    <xsl:value-of select="position() - 1"/>
                                                </xsl:if>
                                            </xsl:for-each>
                                        </xsl:when>
                                        
                                        <xsl:otherwise>
                                            <xsl:for-each select="$unique-blocks">
                                                <xsl:sort select="@order"/>
                                                <xsl:if test="count(.|$the-block) = 1">
                                                    <xsl:value-of select="position() - 1"/>
                                                </xsl:if>
                                            </xsl:for-each>
                                        </xsl:otherwise>
                                    </xsl:choose>
                                </xsl:otherwise>
                            </xsl:choose>
                            
                            
                            <xsl:if test="not(@correct= 'no')">
                                <xsl:text> </xsl:text>
                            </xsl:if>
                        </xsl:for-each>
                    </xsl:variable>
                    
                    <xsl:attribute name="data-blockanswer">
                        <xsl:value-of select="substring($blockanswer, 1, string-length($blockanswer) - 1)"/>
                    </xsl:attribute>
                    
                    
                    
                    <xsl:text>
--blocks--
</xsl:text>
                    <xsl:choose>
                        
                        <xsl:when test="$b-randomize">
                            <xsl:apply-templates select="$unique-blocks" mode="horizontal-blocks">
                                <xsl:with-param name="b-natural" select="$b-natural"/>
                            </xsl:apply-templates>
                        </xsl:when>
                        
                        <xsl:otherwise>
                            <xsl:for-each select="$unique-blocks">
                                <xsl:sort select="@order"/>
                                <xsl:apply-templates select="." mode="horizontal-blocks">
                                    <xsl:with-param name="b-natural" select="$b-natural"/>
                                </xsl:apply-templates>
                            </xsl:for-each>
                        </xsl:otherwise>
                    </xsl:choose>
                    
                    
                    <xsl:if test="tests">
                        <xsl:text>--unittest--
</xsl:text>
                        <xsl:call-template name="sanitize-text">
                            <xsl:with-param name="text" select="tests" />
                        </xsl:call-template>
                    </xsl:if>

PTX:WARNING: a block of a horizontal Parson problem with code needs to be enclosed in a "c" element

(NEEDS "c" ELEMENT)

_drag

- p r

random ab-experiment first any random

toggle, lock togglelabels: toggle togglelabels:

Loading a select question (grading type: )...

Number Text

[

] ,

] { "number": [

] , "feedback": "

} { "regex": "

^\s*

\s*$

" , "regexFlags": " i " , "feedback": "

}

You can write here, and it will be saved on this device, but your response will not be graded.

_question

<xsl:if test="stdin">
                                <xsl:attribute name="data-stdin">
                                    <xsl:call-template name="sanitize-text">
                                        <xsl:with-param name="text" select="stdin" />
                                    </xsl:call-template>
                                </xsl:attribute>
                            </xsl:if>
                            <xsl:attribute name="id">
                                <xsl:value-of select="$rsid"/>
                                <xsl:text>_editor</xsl:text>
                            </xsl:attribute>
                            
                            <xsl:call-template name="runestone-activecode-editor-attributes">
                                <xsl:with-param name="active-language" select="$active-language"/>
                                <xsl:with-param name="hosting" select="$hosting"/>
                            </xsl:call-template>
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            
                            <xsl:if test="@codetailor">
                                <xsl:attribute name="data-parsonspersonalize">
                                    <xsl:choose>
                                        <xsl:when test="@codetailor = 'incorrect'">
                                            <xsl:text>partial</xsl:text>
                                        </xsl:when>
                                        
                                        <xsl:otherwise>
                                            <xsl:text>movable</xsl:text>
                                        </xsl:otherwise>
                                    </xsl:choose>
                                </xsl:attribute>
                                <xsl:attribute name="data-parsonsexample">
                                    <xsl:choose>
                                        <xsl:when test="@codetailor-fallback">
                                            <xsl:call-template name="runestone-targets">
                                                <xsl:with-param name="id-list" select="@codetailor-fallback"/>
                                                <xsl:with-param name="separator" select="''"/>
                                            </xsl:call-template>
                                        </xsl:when>
                                        <xsl:otherwise>
                                            <xsl:text>LLM-example</xsl:text>
                                        </xsl:otherwise>
                                    </xsl:choose>
                                </xsl:attribute>
                            </xsl:if>
                            
                            
                            
                            
                            
                            <xsl:variable name="program-preamble-trimmed">
                                <xsl:apply-templates select="preamble" mode="program-part-processing"/>
                            </xsl:variable>
                            <xsl:variable name="program-code-trimmed">
                                <xsl:apply-templates select="code" mode="program-part-processing"/>
                            </xsl:variable>
                            <xsl:variable name="program-postamble-trimmed">
                                <xsl:apply-templates select="postamble" mode="program-part-processing"/>
                            </xsl:variable>
                            
                            <xsl:variable name="program-left-margin">
                                <xsl:call-template name="count-pad-length">
                                    <xsl:with-param name="text">
                                        
                                        
                                        <xsl:call-template name="trim-start-lines">
                                            <xsl:with-param name="text">
                                                <xsl:value-of select="$program-preamble-trimmed"/>
                                                <xsl:value-of select="$program-code-trimmed"/>
                                                <xsl:value-of select="$program-postamble-trimmed"/>
                                            </xsl:with-param>
                                        </xsl:call-template>
                                    </xsl:with-param>
                                </xsl:call-template>
                            </xsl:variable>
                            
                            <xsl:variable name="left-margin-string">
                                <xsl:value-of select="str:padding($program-left-margin, ' ')" />
                            </xsl:variable>
                            
                            
                            <xsl:variable name="program-text">
                                <xsl:for-each select="preamble">
                                    
                                    <xsl:value-of select="$program-preamble-trimmed"/>
                                    <xsl:value-of select="$left-margin-string"/>
                                    <xsl:choose>
                                        <xsl:when test='@visible = "no"'>
                                            <xsl:text>^^^^
</xsl:text>
                                        </xsl:when>
                                        <xsl:otherwise>
                                            <xsl:text>^^^!
</xsl:text>
                                        </xsl:otherwise>
                                    </xsl:choose>
                                </xsl:for-each>
                                
                                <xsl:value-of select="$program-code-trimmed"/>
                                
                                <xsl:for-each select="postamble">
                                    
                                    <xsl:value-of select="$left-margin-string"/>
                                    <xsl:choose>
                                        <xsl:when test='@visible = "no"'>
                                            <xsl:text>====
</xsl:text>
                                        </xsl:when>
                                        <xsl:otherwise>
                                            <xsl:text>===!
</xsl:text>
                                        </xsl:otherwise>
                                    </xsl:choose>
                                    <xsl:value-of select="$program-postamble-trimmed"/>
                                </xsl:for-each>
                            </xsl:variable>
                            
                            <xsl:call-template name="sanitize-text">
                                <xsl:with-param name="text" select="$program-text" />
                            </xsl:call-template>
                            
                            <xsl:if test="tests">
                                
                                
                                
                                
                                
                                
                                <xsl:variable name="tests-content">
                                    <xsl:variable name="trimmed-text">
                                        <xsl:apply-templates select="tests" mode="program-part-processing"/>
                                    </xsl:variable>
                                    <xsl:call-template name="left-align-text">
                                        <xsl:with-param name="text" select="$trimmed-text" />
                                    </xsl:call-template>
                                </xsl:variable>
                                
                                <xsl:if test="not(normalize-space($tests-content) = '')">
                                    <xsl:choose>
                                        <xsl:when test="tests[@visible = 'yes']">
                                            <xsl:choose>
                                                <xsl:when test="postamble[@visible = 'no']">
                                                    <xsl:message>PTX:WARNING: There is no support for visible tests after an invisible postamble. (Issue in <xsl:value-of select="$rsid"/>).</xsl:message>
                                                </xsl:when>
                                                <xsl:when test="not(postamble)">
                                                    
                                                    <xsl:text>===!
</xsl:text>
                                                </xsl:when>
                                                
                                            </xsl:choose>
                                        </xsl:when>
                                        <xsl:otherwise>
                                            
                                            <xsl:if test="not(postamble[@visible = 'no'])">
                                                <xsl:text>====
</xsl:text>
                                            </xsl:if>
                                        </xsl:otherwise>
                                    </xsl:choose>
                                    <xsl:value-of select="$tests-content"/>
                                </xsl:if>
                                <xsl:if test="tests/iotest">
                                    <xsl:choose>
                                        <xsl:when test="not(normalize-space(tests/text()) = '')">
                                            <xsl:message>PTX:FALLBACK: You can either write text based tests or use iotests, but not both. iotests ignored in <xsl:value-of select="$rsid"/>.</xsl:message>
                                        </xsl:when>
                                        <xsl:otherwise>
                                            <xsl:text>===iotests===
</xsl:text>
                                            <xsl:text>[</xsl:text>
                                            <xsl:for-each select="tests/iotest">
                                                <xsl:text>{"input":"</xsl:text>
                                                <xsl:call-template name="escape-json-string">
                                                    <xsl:with-param name="text">
                                                        <xsl:call-template name="sanitize-text">
                                                            <xsl:with-param name="text">
                                                                <xsl:value-of select="input"/>
                                                            </xsl:with-param>
                                                        </xsl:call-template>
                                                    </xsl:with-param>
                                                </xsl:call-template>
                                                <xsl:text>","out":"</xsl:text>
                                                <xsl:call-template name="escape-json-string">
                                                    <xsl:with-param name="text">
                                                        <xsl:call-template name="sanitize-text">
                                                            <xsl:with-param name="text">
                                                                <xsl:value-of select="output"/>
                                                            </xsl:with-param>
                                                        </xsl:call-template>
                                                    </xsl:with-param>
                                                </xsl:call-template>
                                                <xsl:text>"}</xsl:text>
                                                <xsl:if test="position() != last()">
                                                    <xsl:text>,</xsl:text>
                                                </xsl:if>
                                            </xsl:for-each>
                                            <xsl:text>]
</xsl:text>
                                        </xsl:otherwise>
                                    </xsl:choose>
                                </xsl:if>
                            </xsl:if>

false true true false

/_static

gdscript/

.zip

yes yes yes yes

{ "embeddedMode": true, "lang": "

", "jumpToEnd": false }

trace/

browser browser browser browser browser jobeserver jobeserver jobeserver jobeserver jobeserver jobeserver jobeserver

pre textarea


                
                Data:

data:

;base64,

datafile

runestone tabbed_section contains-wide

(

)

instructor

[

' ,

]

PTX:ERROR: an @xml:id value "" was used to specify a runestone component but no item with that id exists.

PTX:BUG: runestone-targets template was called with an invalid @output-field value ""