bare-script 4.1.3__tar.gz → 4.1.5__tar.gz

{bare_script-4.1.3/src/bare_script.egg-info → bare_script-4.1.5}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: bare-script
-Version: 4.1.3
+Version: 4.1.5
 Summary: bare-script
 Home-page: https://github.com/craigahobbs/bare-script
 Author: Craig A. Hobbs
@@ -199,6 +199,32 @@ automatically; otherwise the pure-Python runtime is used as a fallback. Set the
 variable `BARESCRIPT_RUNTIME_PY=1` to force the pure-Python runtime.
 
 
+## Using BareScript with an AI Assistant
+
+This repository ships a
+[`SKILL.md`](https://github.com/craigahobbs/bare-script-py/blob/main/SKILL.md)
+file that teaches an AI coding assistant how to write idiomatic BareScript — language syntax, the
+built-in and include libraries, the MarkdownUp application pattern, and the unit-test conventions.
+It is plain Markdown and applies to either BareScript implementation.
+
+For [Claude Code](https://claude.com/claude-code) and other tools that follow the
+[Agent Skills](https://docs.claude.com/en/docs/agents-and-tools/agent-skills/overview)
+convention, install it as a project or user skill:
+
+```
+mkdir -p .claude/skills/bare-script
+cp SKILL.md .claude/skills/bare-script/SKILL.md
+```
+
+Use `~/.claude/skills/bare-script/SKILL.md` instead to make it available across all projects. For
+other assistants, include the file's contents in your system prompt or rules file.
+
+Once installed, you can prompt the assistant with tasks like:
+
+> Build a MarkdownUp application that plays tic-tac-toe against the user, with a reset button
+> and a running win/loss/draw tally rendered as a bar chart.
+
+
 ## Development
 
 This package is developed using [python-build](https://github.com/craigahobbs/python-build#readme).

{bare_script-4.1.3 → bare_script-4.1.5}/README.md

@@ -174,6 +174,32 @@ automatically; otherwise the pure-Python runtime is used as a fallback. Set the
 variable `BARESCRIPT_RUNTIME_PY=1` to force the pure-Python runtime.
 
 
+## Using BareScript with an AI Assistant
+
+This repository ships a
+[`SKILL.md`](https://github.com/craigahobbs/bare-script-py/blob/main/SKILL.md)
+file that teaches an AI coding assistant how to write idiomatic BareScript — language syntax, the
+built-in and include libraries, the MarkdownUp application pattern, and the unit-test conventions.
+It is plain Markdown and applies to either BareScript implementation.
+
+For [Claude Code](https://claude.com/claude-code) and other tools that follow the
+[Agent Skills](https://docs.claude.com/en/docs/agents-and-tools/agent-skills/overview)
+convention, install it as a project or user skill:
+
+```
+mkdir -p .claude/skills/bare-script
+cp SKILL.md .claude/skills/bare-script/SKILL.md
+```
+
+Use `~/.claude/skills/bare-script/SKILL.md` instead to make it available across all projects. For
+other assistants, include the file's contents in your system prompt or rules file.
+
+Once installed, you can prompt the assistant with tasks like:
+
+> Build a MarkdownUp application that plays tic-tac-toe against the user, with a reset button
+> and a running win/loss/draw tally rendered as a bar chart.
+
+
 ## Development
 
 This package is developed using [python-build](https://github.com/craigahobbs/python-build#readme).

{bare_script-4.1.3 → bare_script-4.1.5}/setup.cfg

@@ -1,6 +1,6 @@
 [metadata]
 name = bare-script
-version = 4.1.3
+version = 4.1.5
 url = https://github.com/craigahobbs/bare-script
 author = Craig A. Hobbs
 author_email = craigahobbs@gmail.com

{bare_script-4.1.3 → bare_script-4.1.5}/src/bare_script/include/data.bare

@@ -33,8 +33,8 @@ function dataParseCSV(text):
         linePart = line
         while linePart != null:
             # Quoted field?
-            mQuoted = regexMatch(dataParseCSVQuotedField, linePart)
-            if mQuoted != null:
+            mQuoted = stringStartsWith(linePart, '"') && regexMatch(dataParseCSVQuotedField, linePart)
+            if mQuoted:
                 groups = objectGet(mQuoted, 'groups')
                 arrayPush(row, stringReplace(objectGet(groups, '1'), '""', '"'))
                 linePart = stringSlice(linePart, stringLength(objectGet(groups, '0')))
@@ -96,8 +96,8 @@ function dataValidate(data, csv):
     types = {}
     for row in data:
         for field in objectKeys(row):
-            value = objectGet(row, field)
             if !objectGet(types, field):
+                value = objectGet(row, field)
                 valueType = systemType(value)
                 if valueType == 'boolean':
                     objectSet(types, field, 'boolean')
@@ -137,14 +137,12 @@ function dataValidate(data, csv):
         endif
     endfor
 
-    # Validate field values
+    # Validate field values (typeKeys ensures fieldType is always set by the fix-up pass above)
+    typeKeys = objectKeys(types)
     for row in data:
-        for field in objectKeys(row):
+        for field in typeKeys:
             value = objectGet(row, field)
             fieldType = objectGet(types, field)
-            if fieldType == null:
-                continue
-            endif
             valueType = systemType(value)
 
             # Null string?
@@ -324,10 +322,15 @@ function dataCalculatedField(data, fieldName, expr, variables):
     calcExpr = barescriptParseExpression(expr, false)
 
     # Compute the calculated field for each row
-    for row in data:
-        rowVars = if(variables != null, objectAssign(objectCopy(row), variables), row)
-        objectSet(row, fieldName, barescriptEvaluateExpression(calcExpr, rowVars))
-    endfor
+    if variables != null:
+        for row in data:
+            objectSet(row, fieldName, barescriptEvaluateExpression(calcExpr, objectAssign(objectCopy(row), variables)))
+        endfor
+    else:
+        for row in data:
+            objectSet(row, fieldName, barescriptEvaluateExpression(calcExpr, row))
+        endfor
+    endif
 
     return data
 endfunction
@@ -347,12 +350,19 @@ function dataFilter(data, expr, variables):
     filterExpr = barescriptParseExpression(expr, false)
 
     # Filter the data
-    for row in data:
-        rowVars = if(variables != null, objectAssign(objectCopy(row), variables), row)
-        if systemBoolean(barescriptEvaluateExpression(filterExpr, rowVars)):
-            arrayPush(result, row)
-        endif
-    endfor
+    if variables != null:
+        for row in data:
+            if barescriptEvaluateExpression(filterExpr, objectAssign(objectCopy(row), variables)):
+                arrayPush(result, row)
+            endif
+        endfor
+    else:
+        for row in data:
+            if barescriptEvaluateExpression(filterExpr, row):
+                arrayPush(result, row)
+            endif
+        endfor
+    endif
 
     return result
 endfunction
@@ -374,6 +384,17 @@ function dataAggregate(data, aggregation):
     categories = objectGet(aggregation, 'categories')
     measures = objectGet(aggregation, 'measures')
 
+    # Precompute per-measure metadata: [outputName, inputFieldKey, function]
+    measureMeta = []
+    for measure in measures:
+        measureFieldKey = objectGet(measure, 'field')
+        arrayPush(measureMeta, [ \
+            objectGet(measure, 'name', measureFieldKey), \
+            measureFieldKey, \
+            objectGet(measure, 'function') \
+        ])
+    endfor
+
     # Create the aggregate rows
     categoryRows = {}
     for row in data:
@@ -391,7 +412,7 @@ function dataAggregate(data, aggregation):
 
         # Get or create the aggregate row
         aggregateRow = objectGet(categoryRows, rowKey)
-        if aggregateRow == null:
+        if !aggregateRow:
             aggregateRow = {}
             objectSet(categoryRows, rowKey, aggregateRow)
             if categories != null:
@@ -402,13 +423,13 @@ function dataAggregate(data, aggregation):
         endif
 
         # Accumulate measure values
-        for measure in measures:
-            measureField = objectGet(measure, 'name', objectGet(measure, 'field'))
-            measureValue = objectGet(row, objectGet(measure, 'field'))
-            measureValues = objectGet(aggregateRow, measureField)
+        for meta in measureMeta:
+            measureName = arrayGet(meta, 0)
+            measureValue = objectGet(row, arrayGet(meta, 1))
+            measureValues = objectGet(aggregateRow, measureName)
             if measureValues == null:
                 measureValues = []
-                objectSet(aggregateRow, measureField, measureValues)
+                objectSet(aggregateRow, measureName, measureValues)
             endif
             if measureValue != null:
                 arrayPush(measureValues, measureValue)
@@ -421,32 +442,32 @@ function dataAggregate(data, aggregation):
     for categoryRowsKey in objectKeys(categoryRows):
         aggregateRow = objectGet(categoryRows, categoryRowsKey)
         arrayPush(aggregateRows, aggregateRow)
-        for measure in measures:
-            measureField = objectGet(measure, 'name', objectGet(measure, 'field'))
-            measureFunc = objectGet(measure, 'function')
-            measureValues = objectGet(aggregateRow, measureField)
+        for meta in measureMeta:
+            measureName = arrayGet(meta, 0)
+            measureFunc = arrayGet(meta, 2)
+            measureValues = objectGet(aggregateRow, measureName)
             if !arrayLength(measureValues):
-                objectSet(aggregateRow, measureField, null)
+                objectSet(aggregateRow, measureName, null)
             elif measureFunc == 'count':
-                objectSet(aggregateRow, measureField, arrayLength(measureValues))
+                objectSet(aggregateRow, measureName, arrayLength(measureValues))
             elif measureFunc == 'max':
                 maxVal = arrayGet(measureValues, 0)
                 for val in measureValues:
                     maxVal = if(val > maxVal, val, maxVal)
                 endfor
-                objectSet(aggregateRow, measureField, maxVal)
+                objectSet(aggregateRow, measureName, maxVal)
             elif measureFunc == 'min':
                 minVal = arrayGet(measureValues, 0)
                 for val in measureValues:
                     minVal = if(val < minVal, val, minVal)
                 endfor
-                objectSet(aggregateRow, measureField, minVal)
+                objectSet(aggregateRow, measureName, minVal)
             elif measureFunc == 'sum':
                 sumVal = 0
                 for val in measureValues:
                     sumVal = sumVal + val
                 endfor
-                objectSet(aggregateRow, measureField, sumVal)
+                objectSet(aggregateRow, measureName, sumVal)
             elif measureFunc == 'stddev':
                 sumVal = 0
                 for val in measureValues:
@@ -457,14 +478,14 @@ function dataAggregate(data, aggregation):
                 for val in measureValues:
                     sumSqDiff = sumSqDiff + (val - avgVal) ** 2
                 endfor
-                objectSet(aggregateRow, measureField, mathSqrt(sumSqDiff / arrayLength(measureValues)))
+                objectSet(aggregateRow, measureName, mathSqrt(sumSqDiff / arrayLength(measureValues)))
             else:
                 # measureFunc == 'average'
                 sumVal = 0
                 for val in measureValues:
                     sumVal = sumVal + val
                 endfor
-                objectSet(aggregateRow, measureField, sumVal / arrayLength(measureValues))
+                objectSet(aggregateRow, measureName, sumVal / arrayLength(measureValues))
             endif
         endfor
     endfor

{bare_script-4.1.3 → bare_script-4.1.5}/src/bare_script/include/dataLineChart.bare

@@ -195,22 +195,27 @@ function dataLineChartElements(data, lineChart, options):
     yMin = null
     xMax = null
     yMax = null
+    chartPrecision = objectGet(lineChart, 'precision')
+    chartDatetime = objectGet(lineChart, 'datetime')
     if colorField != null:
         # Determine the set of color encoding values
+        isSingleY = (arrayLength(yFields) == 1)
         colorValueSet = {}
         pointsMap = {}
         for row in data:
+            xRow = objectGet(row, xField)
+            colorValue = dataUtilFormatValue(objectGet(row, colorField), chartPrecision, chartDatetime)
             for yField in yFields:
-                colorValue = dataUtilFormatValue(objectGet(row, colorField), objectGet(lineChart, 'precision'), objectGet(lineChart, 'datetime'))
-                rowKey = if(arrayLength(yFields) == 1, colorValue, yField + ', ' + colorValue)
+                rowKey = if(isSingleY, colorValue, yField + ', ' + colorValue)
                 objectSet(colorValueSet, rowKey, true)
-                xRow = objectGet(row, xField)
                 yRow = objectGet(row, yField)
                 if xRow != null && yRow != null:
-                    if !objectHas(pointsMap, rowKey):
-                        objectSet(pointsMap, rowKey, [])
+                    rowPoints = objectGet(pointsMap, rowKey)
+                    if rowPoints == null:
+                        rowPoints = []
+                        objectSet(pointsMap, rowKey, rowPoints)
                     endif
-                    arrayPush(objectGet(pointsMap, rowKey), [xRow, yRow])
+                    arrayPush(rowPoints, [xRow, yRow])
                     xMin = if(xMin == null, xRow, xMin)
                     yMin = if(yMin == null, yRow, if(yRow < yMin, yRow, yMin))
                     xMax = xRow
@@ -265,8 +270,6 @@ function dataLineChartElements(data, lineChart, options):
     chartTitle = objectGet(lineChart, 'title')
     chartWidth = objectGet(lineChart, 'width', dataLineChartDefaultWidth)
     chartHeight = objectGet(lineChart, 'height', dataLineChartDefaultHeight)
-    chartPrecision = objectGet(lineChart, 'precision')
-    chartDatetime = objectGet(lineChart, 'datetime')
 
     # Compute Y-axis tick values
     yAxisTicks = []
@@ -515,29 +518,46 @@ function dataLineChartElements(data, lineChart, options):
 
     # Render lines
     lineElements = []
+    xRange = xMax - xMin
+    yRange = yMax - yMin
+    xScale = if(xRange == 0, 0, (chartRight - chartLeft) / xRange)
+    yScale = if(yRange == 0, 0, (chartTop - chartBottom) / yRange)
+    svgPrecision = dataLineChartSvgPrecision
+    chartLineWidthValue = numberToFixed(dataLineChartChartLineWidth, svgPrecision)
     for linePoint in linePointsReversed:
         linePointColor = objectGet(linePoint, 'color')
         linePointPoints = objectGet(linePoint, 'points')
         linePointParts = []
-        for point, ixPoint in linePointPoints:
-            xCoord = arrayGet(point, 0)
-            yCoord = arrayGet(point, 1)
-            xPoint = dataLineChartChartPoint(xCoord, xMin, xMax, chartLeft, chartRight)
-            yPoint = dataLineChartChartPoint(yCoord, yMin, yMax, chartBottom, chartTop)
-            if arrayLength(linePointPoints) == 1:
-                arrayPush(linePointParts, \
-                    'M ' + dataLineChartSvgValue(xPoint - 0.5 * dataLineChartChartLineWidth) + ' ' + dataLineChartSvgValue(yPoint) + \
-                    ' L ' + dataLineChartSvgValue(xPoint + 0.5 * dataLineChartChartLineWidth) + ' ' + dataLineChartSvgValue(yPoint))
-            else:
+        nPoints = arrayLength(linePointPoints)
+        if nPoints == 1:
+            point = arrayGet(linePointPoints, 0)
+            xPoint = chartLeft + (arrayGet(point, 0) - xMin) * xScale
+            yPoint = chartBottom + (arrayGet(point, 1) - yMin) * yScale
+            yPointStr = numberToFixed(yPoint, svgPrecision)
+            arrayPush(linePointParts, \
+                'M ' + numberToFixed(xPoint - 0.5 * dataLineChartChartLineWidth, svgPrecision) + ' ' + yPointStr + \
+                ' L ' + numberToFixed(xPoint + 0.5 * dataLineChartChartLineWidth, svgPrecision) + ' ' + yPointStr)
+        else:
+            firstPoint = arrayGet(linePointPoints, 0)
+            xPoint = chartLeft + (arrayGet(firstPoint, 0) - xMin) * xScale
+            yPoint = chartBottom + (arrayGet(firstPoint, 1) - yMin) * yScale
+            arrayPush(linePointParts, \
+                'M ' + numberToFixed(xPoint, svgPrecision) + ' ' + numberToFixed(yPoint, svgPrecision))
+            ixPoint = 1
+            while ixPoint < nPoints:
+                point = arrayGet(linePointPoints, ixPoint)
+                xPoint = chartLeft + (arrayGet(point, 0) - xMin) * xScale
+                yPoint = chartBottom + (arrayGet(point, 1) - yMin) * yScale
                 arrayPush(linePointParts, \
-                    if(ixPoint == 0, 'M ', 'L ') + dataLineChartSvgValue(xPoint) + ' ' + dataLineChartSvgValue(yPoint))
-            endif
-        endfor
+                    'L ' + numberToFixed(xPoint, svgPrecision) + ' ' + numberToFixed(yPoint, svgPrecision))
+                ixPoint = ixPoint + 1
+            endwhile
+        endif
         arrayPush(lineElements, { \
             'svg': 'path', \
             'attr': { \
                 'stroke': linePointColor, \
-                'stroke-width': dataLineChartSvgValue(dataLineChartChartLineWidth), \
+                'stroke-width': chartLineWidthValue, \
                 'fill': 'none', \
                 'd': arrayJoin(linePointParts, ' ') \
             } \

{bare_script-4.1.3 → bare_script-4.1.5}/src/bare_script/include/dataTable.bare

@@ -111,55 +111,60 @@ function dataTableMarkdown(data, model):
     precisionTrim = if(model != null, objectGet(model, 'trim', true), true)
     formats = if(model != null, objectGet(model, 'formats'))
 
-    # Compute the field header widths
+    # Initialize widths to the field header width
     widths = {}
     for field in fields:
-        fieldWidth = stringLength(field)
-        if !objectHas(widths, field) || fieldWidth > objectGet(widths, field):
-            objectSet(widths, field, fieldWidth)
-        endif
+        objectSet(widths, field, stringLength(field))
     endfor
 
     # Compute the formatted field value strings and widths
+    hasDatetimeFormat = precisionDatetime != null
     dataFormat = []
     for row in data:
         rowFormat = {}
         arrayPush(dataFormat, rowFormat)
         for field in fields:
-            # Format the value
+            # Format the value (newline regex only on string/other types - numbers and datetimes can't contain newlines)
             value = objectGet(row, field)
             valueType = systemType(value)
-            if valueType == 'string':
-                valueFormat = stringTrim(value)
-            elif valueType == 'number':
+            if valueType == 'number':
                 valueFormat = numberToFixed(value, precisionNumber, precisionTrim)
             elif valueType == 'datetime':
-                valueFormat = datetimeISOFormat(value, precisionDatetime != null)
+                valueFormat = datetimeISOFormat(value, hasDatetimeFormat)
             else:
-                valueFormat = stringNew(value)
+                valueFormat = if(valueType == 'string', stringTrim(value), stringNew(value))
+                valueFormat = regexReplace(dataTableMarkdownRegexMultipleNewline, valueFormat, '<br><br>')
+                valueFormat = regexReplace(dataTableMarkdownRegexSingleNewline, valueFormat, ' ')
             endif
 
-            # Eliminate value string newlines
-            valueFormat = regexReplace(dataTableMarkdownRegexMultipleNewline, valueFormat, '<br><br>')
-            valueFormat = regexReplace(dataTableMarkdownRegexSingleNewline, valueFormat, ' ')
-
             # Set the field value string
             objectSet(rowFormat, field, valueFormat)
 
-            # Update the field width
+            # Update the field width (widths is initialized above for every field)
             valueWidth = stringLength(valueFormat)
-            if !objectHas(widths, field) || valueWidth > objectGet(widths, field):
+            if valueWidth > objectGet(widths, field):
                 objectSet(widths, field, valueWidth)
             endif
         endfor
     endfor
 
-    # Compute the field header separator
-    headerSeparator = ''
+    # Precompute per-field rendering metadata: [field, width, align, header]
+    fieldMeta = []
     for field in fields:
-        width = objectGet(widths, field)
         format = if(formats != null, objectGet(formats, field))
-        align = if(format != null, objectGet(format, 'align'))
+        arrayPush(fieldMeta, [ \
+            field, \
+            objectGet(widths, field), \
+            if(format != null, objectGet(format, 'align')), \
+            if(format != null, objectGet(format, 'header', field), field) \
+        ])
+    endfor
+
+    # Compute the field header separator
+    headerSeparator = ''
+    for meta in fieldMeta:
+        width = arrayGet(meta, 1)
+        align = arrayGet(meta, 2)
         alignLeft = if(align == 'center', ':', '-')
         alignRight = if(align == 'center' || align == 'right', ':', '-')
         headerSeparator = headerSeparator + '|' + alignLeft + dataTableMarkdownField('', width, align, '-') + alignRight
@@ -168,11 +173,10 @@ function dataTableMarkdown(data, model):
 
     # Compute the table header fields
     headerFields = ''
-    for field in fields:
-        width = objectGet(widths, field)
-        format = if(formats != null, objectGet(formats, field))
-        align = if(format != null, objectGet(format, 'align'))
-        header = if(format != null, objectGet(format, 'header', field), field)
+    for meta in fieldMeta:
+        width = arrayGet(meta, 1)
+        align = arrayGet(meta, 2)
+        header = arrayGet(meta, 3)
         headerFields = headerFields + '| ' + dataTableMarkdownField(header, width, align, ' ') + ' '
     endfor
     headerFields = headerFields + '|'
@@ -184,15 +188,14 @@ function dataTableMarkdown(data, model):
 
     # Output each row
     for row in dataFormat:
-        line = ''
-        for field in fields:
-            width = objectGet(widths, field)
-            format = if(formats != null, objectGet(formats, field))
-            align = if(format != null, objectGet(format, 'align'))
-            line = line + '| ' + dataTableMarkdownField(objectGet(row, field), width, align, ' ') + ' '
+        parts = []
+        for meta in fieldMeta:
+            field = arrayGet(meta, 0)
+            width = arrayGet(meta, 1)
+            align = arrayGet(meta, 2)
+            arrayPush(parts, dataTableMarkdownField(objectGet(row, field), width, align, ' '))
         endfor
-        line = line + '|'
-        arrayPush(lines, line)
+        arrayPush(lines, '| ' + arrayJoin(parts, ' | ') + ' |')
     endfor
 
     return lines
@@ -271,20 +274,34 @@ function dataTableElements(data, dataTable):
     resultRows = []
     resultElements = {'html': 'table', 'elem': resultRows}
 
-    # Header row
-    headerRowElements = []
+    # Precompute per-field metadata: [field, isCategory, attr, isMarkdown, headerText]
     fieldArrays = [categories, tableFields]
-    for fieldArray in fieldArrays:
+    fieldMeta = []
+    for fieldArray, ixFieldArray in fieldArrays:
+        isCategory = ixFieldArray == 0
         for field in fieldArray:
             fieldFormat = if(fieldFormats != null, objectGet(fieldFormats, field))
-            formatHeader = if(fieldFormat != null, objectGet(fieldFormat, 'header'))
-            arrayPush(headerRowElements, { \
-                'html': 'th', \
-                'attr': dataTableElementsFieldAttr(fieldFormat), \
-                'elem': {'text': formatHeader || field} \
-            })
+            arrayPush(fieldMeta, [ \
+                field, \
+                isCategory, \
+                dataTableElementsFieldAttr(fieldFormat), \
+                fieldFormat != null && objectGet(fieldFormat, 'markdown'), \
+                if(fieldFormat != null, objectGet(fieldFormat, 'header')) || field \
+            ])
         endfor
     endfor
+
+    # Header row
+    headerRowElements = []
+    for meta in fieldMeta:
+        fieldAttr = arrayGet(meta, 2)
+        headerText = arrayGet(meta, 4)
+        arrayPush(headerRowElements, { \
+            'html': 'th', \
+            'attr': fieldAttr, \
+            'elem': {'text': headerText} \
+        })
+    endfor
     arrayPush(resultRows, {'html': 'tr', 'elem': headerRowElements})
 
     # Generate the data table's element model
@@ -292,26 +309,27 @@ function dataTableElements(data, dataTable):
         rowPrev = if(ixRow > 0, arrayGet(data, ixRow - 1))
         skip = rowPrev != null
         fieldRowElements = []
-        for fieldArray, ixFieldArray in fieldArrays:
-            for field in fieldArray:
-                value = objectGet(row, field)
+        for meta in fieldMeta:
+            field = arrayGet(meta, 0)
+            fieldAttr = arrayGet(meta, 2)
+            isMarkdown = arrayGet(meta, 3)
+            value = objectGet(row, field)
 
-                # Skip this value?
-                if skip:
-                    skip = ixFieldArray == 0 && systemCompare(value, objectGet(rowPrev, field)) == 0
-                endif
+            # Skip this value?
+            if skip:
+                isCategory = arrayGet(meta, 1)
+                skip = isCategory && systemCompare(value, objectGet(rowPrev, field)) == 0
+            endif
 
-                fieldFormat = if(fieldFormats != null, objectGet(fieldFormats, field))
-                fieldElements = if(fieldFormat != null && objectGet(fieldFormat, 'markdown'), \
-                    markdownElements(markdownParse(stringNew(value))), \
-                    {'text': dataUtilFormatValue(value, formatPrecision, formatDatetime, formatTrim)} \
-                )
-                arrayPush(fieldRowElements, { \
-                    'html': 'td', \
-                    'attr': dataTableElementsFieldAttr(fieldFormat), \
-                    'elem': if(skip, null, fieldElements) \
-                })
-            endfor
+            fieldElements = if(isMarkdown, \
+                markdownElements(markdownParse(stringNew(value))), \
+                {'text': dataUtilFormatValue(value, formatPrecision, formatDatetime, formatTrim)} \
+            )
+            arrayPush(fieldRowElements, { \
+                'html': 'td', \
+                'attr': fieldAttr, \
+                'elem': if(skip, null, fieldElements) \
+            })
         endfor
         arrayPush(resultRows, {'html': 'tr', 'elem': fieldRowElements})
     endfor