@santi020k/lumen-core 1.4.0 → 1.7.0

package/dist/charts.js

@@ -36,15 +36,19 @@ const lumenPieChartVariantClassNames = {
 };
 const defaultChartSize = 100;
 const defaultChartPadding = 4;
-const finiteValues = (values) => values.filter((value) => value !== null && Number.isFinite(value));
 export const hasLumenChartData = (series) => series.some(item => item.data.some(datum => datum.y !== null && Number.isFinite(datum.y)));
 export const hasLumenPieData = (data) => data.some(datum => datum.y !== null && Number.isFinite(datum.y) && datum.y > 0);
 export const getLumenChartDomain = (values, includeZero = true) => {
-    const available = finiteValues(values);
-    if (available.length === 0)
+    let min = Number.POSITIVE_INFINITY;
+    let max = Number.NEGATIVE_INFINITY;
+    for (const value of values) {
+        if (value === null || !Number.isFinite(value))
+            continue;
+        min = Math.min(min, value);
+        max = Math.max(max, value);
+    }
+    if (!Number.isFinite(min) || !Number.isFinite(max))
         return { max: 1, min: 0 };
-    let min = Math.min(...available);
-    let max = Math.max(...available);
     if (includeZero) {
         min = Math.min(0, min);
         max = Math.max(0, max);
@@ -56,6 +60,13 @@ export const getLumenChartDomain = (values, includeZero = true) => {
     }
     return { max, min };
 };
+const resolveLumenChartDomain = (values, requested, includeZero) => {
+    const calculated = getLumenChartDomain(values, includeZero);
+    return {
+        max: requested?.max ?? calculated.max,
+        min: requested?.min ?? calculated.min
+    };
+};
 export const scaleLumenChartValue = (value, domain, rangeStart, rangeEnd) => {
     const domainSize = domain.max - domain.min;
     if (!Number.isFinite(value) || domainSize === 0)
@@ -65,8 +76,29 @@ export const scaleLumenChartValue = (value, domain, rangeStart, rangeEnd) => {
 };
 export const getLumenChartTicks = (domain, count = 5) => {
     const safeCount = Math.max(2, Math.round(count));
-    const step = (domain.max - domain.min) / (safeCount - 1);
-    return Array.from({ length: safeCount }, (_, index) => domain.min + step * index);
+    const span = domain.max - domain.min;
+    if (!Number.isFinite(span) || span <= 0)
+        return [domain.min, domain.max];
+    const roughStep = span / (safeCount - 1);
+    const magnitude = 10 ** Math.floor(Math.log10(roughStep));
+    const residual = roughStep / magnitude;
+    let niceFactor = 1;
+    if (residual >= 7.5)
+        niceFactor = 10;
+    else if (residual >= 3.5)
+        niceFactor = 5;
+    else if (residual >= 1.5)
+        niceFactor = 2;
+    const step = niceFactor * magnitude;
+    const first = Math.ceil(domain.min / step) * step;
+    const last = Math.floor(domain.max / step) * step;
+    const ticks = [];
+    for (let value = first; value <= last + step / 1000; value += step) {
+        ticks.push(Number(value.toPrecision(12)));
+    }
+    if (ticks.length >= 2)
+        return ticks;
+    return [domain.min, domain.max];
 };
 export const resolveLumenChartTone = (tone, index = 0) => tone ?? lumenChartTones[index % 8] ?? 'series-1';
 export const getLumenChartToneClassName = (tone, index = 0) => lumenChartToneClassNames[resolveLumenChartTone(tone, index)];
@@ -167,14 +199,42 @@ export const createLumenPieGeometry = (data, options = {}) => {
         total
     };
 };
-const splitGeometrySegments = (data, domain, width, height, padding) => {
+export const getLumenChartNumericX = (value, scale) => {
+    if (typeof value === 'number')
+        return Number.isFinite(value) ? value : null;
+    if (scale === 'linear') {
+        const numeric = Number(value);
+        return Number.isFinite(numeric) ? numeric : null;
+    }
+    const timestamp = Date.parse(value);
+    return Number.isFinite(timestamp) ? timestamp : null;
+};
+const getLumenChartXDomain = (data, scale, requested) => {
+    const calculated = getLumenChartDomain(data.map(datum => getLumenChartNumericX(datum.x, scale)), false);
+    return {
+        max: requested?.max ?? calculated.max,
+        min: requested?.min ?? calculated.min
+    };
+};
+const getLumenLineXCoordinate = (datum, index, dataLength, padding, drawableWidth, xScale, xDomain) => {
+    if (xScale === 'categorical') {
+        const denominator = Math.max(1, dataLength - 1);
+        return padding + (dataLength === 1 ? 0.5 : index / denominator) * drawableWidth;
+    }
+    const numericX = getLumenChartNumericX(datum.x, xScale);
+    if (numericX === null || xDomain === undefined)
+        return null;
+    return scaleLumenChartValue(numericX, xDomain, padding, padding + drawableWidth);
+};
+const isAvailableLumenChartY = (value) => value !== null && Number.isFinite(value);
+const splitGeometrySegments = (data, domain, width, height, padding, xScale, xDomain) => {
     const drawableWidth = Math.max(0, width - padding * 2);
     const drawableHeight = Math.max(0, height - padding * 2);
-    const denominator = Math.max(1, data.length - 1);
     const segments = [];
     let current = [];
     for (const [index, datum] of data.entries()) {
-        if (datum.y === null || !Number.isFinite(datum.y)) {
+        const xCoordinate = getLumenLineXCoordinate(datum, index, data.length, padding, drawableWidth, xScale, xDomain);
+        if (!isAvailableLumenChartY(datum.y) || xCoordinate === null) {
             if (current.length > 0)
                 segments.push(current);
             current = [];
@@ -182,8 +242,7 @@ const splitGeometrySegments = (data, domain, width, height, padding) => {
         }
         current.push({
             ...datum,
-            xCoordinate: padding +
-                (data.length === 1 ? 0.5 : index / denominator) * drawableWidth,
+            xCoordinate,
             yCoordinate: scaleLumenChartValue(datum.y, domain, padding + drawableHeight, padding)
         });
     }
@@ -194,39 +253,41 @@ const splitGeometrySegments = (data, domain, width, height, padding) => {
 const segmentPath = (points) => points
     .map((point, index) => `${index === 0 ? 'M' : 'L'} ${point.xCoordinate.toFixed(3)} ${point.yCoordinate.toFixed(3)}`)
     .join(' ');
+const lumenLineAreaPath = (points, baseline) => {
+    const first = points[0];
+    const last = points[points.length - 1];
+    if (!first || !last)
+        return '';
+    return [
+        segmentPath(points),
+        'L',
+        last.xCoordinate.toFixed(3),
+        baseline.toFixed(3),
+        'L',
+        first.xCoordinate.toFixed(3),
+        baseline.toFixed(3),
+        'Z'
+    ].join(' ');
+};
 export const createLumenLineGeometry = (data, options = {}) => {
-    const width = options.width ?? defaultChartSize;
-    const height = options.height ?? defaultChartSize;
-    const padding = options.padding ?? defaultChartPadding;
-    const calculatedDomain = getLumenChartDomain(data.map(datum => datum.y), options.includeZero ?? false);
-    const domain = {
-        max: options.domain?.max ?? calculatedDomain.max,
-        min: options.domain?.min ?? calculatedDomain.min
-    };
-    const segments = splitGeometrySegments(data, domain, width, height, padding);
+    const { domain: requestedDomain, height = defaultChartSize, includeZero = false, padding = defaultChartPadding, width = defaultChartSize, xDomain: requestedXDomain, xScale = 'categorical' } = options;
+    const domainValues = xScale === 'categorical' ?
+        data.map(datum => datum.y) :
+        data
+            .filter(datum => getLumenChartNumericX(datum.x, xScale) !== null)
+            .map(datum => datum.y);
+    const domain = resolveLumenChartDomain(domainValues, requestedDomain, includeZero);
+    const xDomain = xScale === 'categorical' ? undefined : getLumenChartXDomain(data, xScale, requestedXDomain);
+    const segments = splitGeometrySegments(data, domain, width, height, padding, xScale, xDomain);
     const baseline = scaleLumenChartValue(Math.max(domain.min, Math.min(domain.max, 0)), domain, height - padding, padding);
     return {
         areaPaths: segments
-            .map(points => {
-            const first = points[0];
-            const last = points[points.length - 1];
-            if (!first || !last)
-                return '';
-            return [
-                segmentPath(points),
-                'L',
-                last.xCoordinate.toFixed(3),
-                baseline.toFixed(3),
-                'L',
-                first.xCoordinate.toFixed(3),
-                baseline.toFixed(3),
-                'Z'
-            ].join(' ');
-        })
+            .map(points => lumenLineAreaPath(points, baseline))
             .filter(Boolean),
         domain,
         path: segments.map(segmentPath).join(' '),
-        points: segments.flat()
+        points: segments.flat(),
+        ...(xDomain === undefined ? {} : { xDomain })
     };
 };
 export const getLumenChartValueRatio = (value, domain) => {
@@ -244,19 +305,28 @@ export const getLumenChartCategories = (series) => {
     }
     return [...categories.values()];
 };
-export const alignLumenChartSeries = (series, categories) => ({
-    ...series,
-    data: categories.map(category => series.data.find(datum => datum.x === category) ?? {
-        x: category,
-        y: null
-    })
-});
-const getDatumValue = (series, category) => series.data.find(datum => datum.x === category)?.y ?? 0;
+const lumenChartCategoryKey = (category) => `${typeof category}:${String(category)}`;
+const indexLumenChartSeries = (series) => new Map(series.data.map(datum => [lumenChartCategoryKey(datum.x), datum]));
+export const alignLumenChartSeries = (series, categories) => {
+    const indexed = indexLumenChartSeries(series);
+    return {
+        ...series,
+        data: categories.map(category => indexed.get(lumenChartCategoryKey(category)) ?? {
+            x: category,
+            y: null
+        })
+    };
+};
+const getDatumValue = (series, category) => {
+    const value = series.get(lumenChartCategoryKey(category))?.y;
+    return value !== null && value !== undefined && Number.isFinite(value) ? value : 0;
+};
 const getStackedDomain = (series, categories) => {
+    const indexedSeries = series.map(indexLumenChartSeries);
     const totals = categories.flatMap(category => {
         let positive = 0;
         let negative = 0;
-        for (const item of series) {
+        for (const item of indexedSeries) {
             const value = getDatumValue(item, category);
             if (value >= 0)
                 positive += value;
@@ -279,10 +349,15 @@ export const createLumenBarGeometry = (series, options = {}) => {
     const orientation = options.orientation ?? 'vertical';
     const layout = options.layout ?? 'grouped';
     const categories = getLumenChartCategories(series);
+    const indexedSeries = series.map(indexLumenChartSeries);
     const values = series.flatMap(item => item.data.map(datum => datum.y));
-    const domain = layout === 'stacked' ?
+    const calculatedDomain = layout === 'stacked' ?
         getStackedDomain(series, categories) :
         getLumenChartDomain(values);
+    const domain = {
+        max: options.domain?.max ?? calculatedDomain.max,
+        min: options.domain?.min ?? calculatedDomain.min
+    };
     const margin = orientation === 'horizontal' ?
         {
             bottom: 24,
@@ -319,7 +394,12 @@ export const createLumenBarGeometry = (series, options = {}) => {
                 height - 20
         });
         for (const [seriesIndex, item] of series.entries()) {
-            const value = getDatumValue(item, category);
+            const indexed = indexedSeries[seriesIndex];
+            if (!indexed)
+                continue;
+            const value = indexed.get(lumenChartCategoryKey(category))?.y;
+            if (value === null || value === undefined || !Number.isFinite(value))
+                continue;
             const tone = resolveLumenChartTone(item.tone, seriesIndex);
             if (orientation === 'horizontal') {
                 const startValue = getBarStartValue(layout, value, positiveOffset, negativeOffset);
@@ -378,3 +458,320 @@ export const createLumenBarGeometry = (series, options = {}) => {
     };
 };
 /* eslint-enable complexity */
+export const summarizeLumenChart = (series) => {
+    let availablePointCount = 0;
+    let maximum = Number.NEGATIVE_INFINITY;
+    let minimum = Number.POSITIVE_INFINITY;
+    let missingPointCount = 0;
+    for (const item of series) {
+        for (const datum of item.data) {
+            if (datum.y === null || !Number.isFinite(datum.y)) {
+                missingPointCount += 1;
+                continue;
+            }
+            availablePointCount += 1;
+            maximum = Math.max(maximum, datum.y);
+            minimum = Math.min(minimum, datum.y);
+        }
+    }
+    return {
+        availablePointCount,
+        maximum: Number.isFinite(maximum) ? maximum : null,
+        minimum: Number.isFinite(minimum) ? minimum : null,
+        missingPointCount,
+        seriesCount: series.length
+    };
+};
+export const formatLumenChartSummary = (series, formatValue = String) => {
+    const summary = summarizeLumenChart(series);
+    if (summary.availablePointCount === 0)
+        return 'No chart data available.';
+    const pointLabel = summary.availablePointCount === 1 ? 'point' : 'points';
+    const missing = summary.missingPointCount === 0 ?
+        '' :
+        ` ${summary.missingPointCount} missing ${summary.missingPointCount === 1 ? 'value' : 'values'}.`;
+    return `${summary.seriesCount} series, ${summary.availablePointCount} ${pointLabel}. ` +
+        `Values range from ${formatValue(summary.minimum ?? 0)} to ${formatValue(summary.maximum ?? 0)}.${missing}`;
+};
+const validateLumenChartDatumId = (datum, context) => {
+    if (datum.id === undefined)
+        return;
+    if (context.datumIds.has(datum.id)) {
+        context.issues.push({
+            code: 'duplicate-datum-id',
+            message: `Datum id "${datum.id}" must be unique within its series.`,
+            path: `${context.path}.id`
+        });
+    }
+    context.datumIds.add(datum.id);
+};
+const validateLumenChartDatumNumbers = (datum, context) => {
+    if (datum.y !== null && !Number.isFinite(datum.y)) {
+        context.issues.push({
+            code: 'invalid-y',
+            message: 'Chart values must be finite numbers or null.',
+            path: `${context.path}.y`
+        });
+    }
+    if (datum.size === undefined || datum.size === null)
+        return;
+    if (!Number.isFinite(datum.size) || datum.size < 0) {
+        context.issues.push({
+            code: 'invalid-size',
+            message: 'Bubble sizes must be finite, non-negative numbers or null.',
+            path: `${context.path}.size`
+        });
+    }
+};
+const validateLumenChartDatumX = (datum, context) => {
+    if (context.xScale === 'categorical')
+        return context.previousX;
+    const numericX = getLumenChartNumericX(datum.x, context.xScale);
+    if (numericX === null) {
+        context.issues.push({
+            code: 'invalid-x',
+            message: `The ${context.xScale} x-axis requires finite numbers or valid ISO dates.`,
+            path: `${context.path}.x`
+        });
+        return context.previousX;
+    }
+    if (numericX < context.previousX) {
+        context.issues.push({
+            code: 'unsorted-x',
+            message: `The ${context.xScale} x-axis data must be sorted in ascending order.`,
+            path: `${context.path}.x`
+        });
+    }
+    return numericX;
+};
+const validateLumenChartDatum = (datum, context) => {
+    validateLumenChartDatumId(datum, context);
+    validateLumenChartDatumNumbers(datum, context);
+    return validateLumenChartDatumX(datum, context);
+};
+export const validateLumenChartSeries = (series, xScale = 'categorical') => {
+    const issues = [];
+    const seriesIds = new Set();
+    for (const [seriesIndex, item] of series.entries()) {
+        const seriesPath = `series[${seriesIndex}]`;
+        if (seriesIds.has(item.id)) {
+            issues.push({
+                code: 'duplicate-series-id',
+                message: `Series id "${item.id}" must be unique.`,
+                path: `${seriesPath}.id`
+            });
+        }
+        seriesIds.add(item.id);
+        const datumIds = new Set();
+        let previousX = Number.NEGATIVE_INFINITY;
+        for (const [datumIndex, datum] of item.data.entries()) {
+            previousX = validateLumenChartDatum(datum, {
+                datumIds,
+                issues,
+                path: `${seriesPath}.data[${datumIndex}]`,
+                previousX,
+                xScale
+            });
+        }
+    }
+    return issues;
+};
+const selectLumenChartBucketDatum = (bucket, first, last, expectedRatio) => {
+    const missing = bucket.find(datum => !isAvailableLumenChartY(datum.y));
+    if (missing)
+        return missing;
+    const expected = !isAvailableLumenChartY(first.y) || !isAvailableLumenChartY(last.y) ?
+        0 :
+        first.y + (last.y - first.y) * expectedRatio;
+    let selected = bucket[0];
+    let largestDistance = Number.NEGATIVE_INFINITY;
+    for (const datum of bucket) {
+        const distance = isAvailableLumenChartY(datum.y) ? Math.abs(datum.y - expected) : 0;
+        if (distance <= largestDistance)
+            continue;
+        largestDistance = distance;
+        selected = datum;
+    }
+    return selected;
+};
+export const downsampleLumenChartData = (data, threshold) => {
+    const safeThreshold = Math.max(3, Math.floor(threshold));
+    if (data.length <= safeThreshold)
+        return [...data];
+    const sampled = [];
+    const first = data[0];
+    const last = data[data.length - 1];
+    if (!first || !last)
+        return [];
+    sampled.push(first);
+    const bucketSize = (data.length - 2) / (safeThreshold - 2);
+    for (let bucketIndex = 0; bucketIndex < safeThreshold - 2; bucketIndex += 1) {
+        const start = 1 + Math.floor(bucketIndex * bucketSize);
+        const end = Math.min(data.length - 1, 1 + Math.floor((bucketIndex + 1) * bucketSize));
+        const bucket = data.slice(start, Math.max(start + 1, end));
+        const expectedRatio = (bucketIndex + 1) / (safeThreshold - 1);
+        const selected = selectLumenChartBucketDatum(bucket, first, last, expectedRatio);
+        if (selected)
+            sampled.push(selected);
+    }
+    sampled.push(last);
+    return sampled;
+};
+export const appendLumenChartDatum = (series, datum, maximumPoints = 500) => {
+    const safeMaximum = Math.max(1, Math.floor(maximumPoints));
+    const data = [...series.data, datum];
+    return {
+        ...series,
+        data: data.slice(Math.max(0, data.length - safeMaximum))
+    };
+};
+const resolveLumenScatterGeometryOptions = (options) => ({
+    height: options.height ?? 320,
+    maximumRadius: options.maximumRadius ?? 18,
+    minimumRadius: options.minimumRadius ?? 4,
+    padding: options.padding ?? 44,
+    requestedDomain: options.domain,
+    requestedXDomain: options.xDomain,
+    width: options.width ?? 640,
+    xScale: options.xScale ?? 'linear'
+});
+const createLumenScatterPoint = (datum, context) => {
+    const numericX = getLumenChartNumericX(datum.x, context.xScale);
+    if (numericX === null || !isAvailableLumenChartY(datum.y))
+        return null;
+    const radius = datum.size === null || datum.size === undefined || !Number.isFinite(datum.size) || datum.size < 0 ?
+        context.minimumRadius :
+        scaleLumenChartValue(datum.size, context.sizeDomain, context.minimumRadius, context.maximumRadius);
+    return {
+        ...datum,
+        radius,
+        seriesId: context.series.id,
+        seriesLabel: context.series.label,
+        tone: resolveLumenChartTone(datum.tone ?? context.series.tone, context.seriesIndex),
+        xCoordinate: scaleLumenChartValue(numericX, context.xDomain, context.padding, context.width - context.padding),
+        yCoordinate: scaleLumenChartValue(datum.y, context.domain, context.height - context.padding, context.padding)
+    };
+};
+export const createLumenScatterGeometry = (series, options = {}) => {
+    const { height, maximumRadius: requestedMaximumRadius, minimumRadius: requestedMinimumRadius, padding, requestedDomain, requestedXDomain, width, xScale } = resolveLumenScatterGeometryOptions(options);
+    const data = series.flatMap(item => item.data);
+    const projectedData = data.filter(datum => (getLumenChartNumericX(datum.x, xScale) !== null && isAvailableLumenChartY(datum.y)));
+    const domain = resolveLumenChartDomain(projectedData.map(datum => datum.y), requestedDomain, false);
+    const xDomain = getLumenChartXDomain(projectedData, xScale, requestedXDomain);
+    const sizes = projectedData.map(datum => (datum.size !== undefined && datum.size !== null && datum.size >= 0 ? datum.size : null));
+    const sizeDomain = getLumenChartDomain(sizes, false);
+    const minimumRadius = Math.max(1, requestedMinimumRadius);
+    const maximumRadius = Math.max(minimumRadius, requestedMaximumRadius);
+    const points = [];
+    for (const [seriesIndex, item] of series.entries()) {
+        for (const datum of item.data) {
+            const point = createLumenScatterPoint(datum, {
+                domain,
+                height,
+                maximumRadius,
+                minimumRadius,
+                padding,
+                series: item,
+                seriesIndex,
+                sizeDomain,
+                width,
+                xDomain,
+                xScale
+            });
+            if (point)
+                points.push(point);
+        }
+    }
+    return { domain, height, points, width, xDomain };
+};
+const uniqueLumenChartCategories = (values) => {
+    const categories = new Map();
+    for (const value of values)
+        categories.set(lumenChartCategoryKey(value), value);
+    return [...categories.values()];
+};
+const createLumenHeatmapCell = (datum, context) => {
+    const xIndex = context.xIndexes.get(lumenChartCategoryKey(datum.x));
+    const yIndex = context.yIndexes.get(lumenChartCategoryKey(datum.y));
+    if (xIndex === undefined || yIndex === undefined)
+        return null;
+    return {
+        ...datum,
+        height: context.cellHeight,
+        ratio: datum.value === null || !Number.isFinite(datum.value) ?
+            0 :
+            getLumenChartValueRatio(datum.value, context.domain),
+        width: context.cellWidth,
+        xCoordinate: xIndex * context.cellWidth,
+        yCoordinate: yIndex * context.cellHeight
+    };
+};
+export const createLumenHeatmapGeometry = (data, width = 640, height = 320) => {
+    const xCategories = uniqueLumenChartCategories(data.map(datum => datum.x));
+    const yCategories = uniqueLumenChartCategories(data.map(datum => datum.y));
+    const domain = getLumenChartDomain(data.map(datum => datum.value), false);
+    const cellWidth = width / Math.max(1, xCategories.length);
+    const cellHeight = height / Math.max(1, yCategories.length);
+    const xIndexes = new Map(xCategories.map((category, index) => [lumenChartCategoryKey(category), index]));
+    const yIndexes = new Map(yCategories.map((category, index) => [lumenChartCategoryKey(category), index]));
+    const cells = data.flatMap(datum => {
+        const cell = createLumenHeatmapCell(datum, {
+            cellHeight,
+            cellWidth,
+            domain,
+            xIndexes,
+            yIndexes
+        });
+        return cell ? [cell] : [];
+    });
+    return { cells, domain, height, width, xCategories, yCategories };
+};
+const createLumenRangePoint = (datum, index, length, width, height, padding, domain) => {
+    if (datum.low === null ||
+        datum.high === null ||
+        !Number.isFinite(datum.low) ||
+        !Number.isFinite(datum.high))
+        return null;
+    const denominator = Math.max(1, length - 1);
+    const xCoordinate = padding + (length === 1 ? 0.5 : index / denominator) * (width - padding * 2);
+    return {
+        ...datum,
+        highCoordinate: scaleLumenChartValue(datum.high, domain, height - padding, padding),
+        lowCoordinate: scaleLumenChartValue(datum.low, domain, height - padding, padding),
+        xCoordinate
+    };
+};
+export const createLumenRangeGeometry = (data, options = {}) => {
+    const { domain: requestedDomain, height = 320, includeZero = false, padding = 44, width = 640 } = options;
+    const values = data.flatMap(datum => (datum.low !== null &&
+        datum.high !== null &&
+        Number.isFinite(datum.low) &&
+        Number.isFinite(datum.high) ?
+        [datum.low, datum.high] :
+        []));
+    const domain = resolveLumenChartDomain(values, requestedDomain, includeZero);
+    const segments = [];
+    let currentSegment = [];
+    for (const [index, datum] of data.entries()) {
+        const point = createLumenRangePoint(datum, index, data.length, width, height, padding, domain);
+        if (!point) {
+            if (currentSegment.length > 0)
+                segments.push(currentSegment);
+            currentSegment = [];
+            continue;
+        }
+        currentSegment.push(point);
+    }
+    if (currentSegment.length > 0)
+        segments.push(currentSegment);
+    const areaPath = segments.map(segment => {
+        const upper = segment.map((point, index) => `${index === 0 ? 'M' : 'L'} ${point.xCoordinate.toFixed(3)} ${point.highCoordinate.toFixed(3)}`);
+        const lower = [...segment].reverse().map(point => `L ${point.xCoordinate.toFixed(3)} ${point.lowCoordinate.toFixed(3)}`);
+        return [...upper, ...lower, 'Z'].join(' ');
+    }).join(' ');
+    return {
+        areaPath,
+        domain,
+        points: segments.flat()
+    };
+};

package/dist/code.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"code.d.ts","sourceRoot":"","sources":["../src/code.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAC5B,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAA;AAEjE,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,kBAAkB,CAAA;IACzB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd;AAED,eAAO,MAAM,wBAAwB;;;;;;;CAOkB,CAAA;AAiPvD,eAAO,MAAM,kBAAkB,GAAI,MAAM,MAAM,WAc9C,CAAA;AA0LD,eAAO,MAAM,iBAAiB,GAC5B,MAAM,MAAM,EACZ,iBAAa,KACZ,cAAc,EA0BhB,CAAA;AAeD,eAAO,MAAM,mBAAmB,GAAI,MAAM,MAAM,EAAE,iBAAa,WAA6E,CAAA"}
+{"version":3,"file":"code.d.ts","sourceRoot":"","sources":["../src/code.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,kBAAkB,GAC5B,QAAQ,GAAG,SAAS,GAAG,SAAS,GAAG,QAAQ,GAAG,QAAQ,GAAG,MAAM,CAAA;AAEjE,MAAM,WAAW,cAAc;IAC7B,IAAI,CAAC,EAAE,kBAAkB,CAAA;IACzB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd;AAED,eAAO,MAAM,wBAAwB;;;;;;;CAOkB,CAAA;AA0QvD,eAAO,MAAM,kBAAkB,GAAI,MAAM,MAAM,WAK9C,CAAA;AA0LD,eAAO,MAAM,iBAAiB,GAC5B,MAAM,MAAM,EACZ,iBAAa,KACZ,cAAc,EA0BhB,CAAA;AAeD,eAAO,MAAM,mBAAmB,GAAI,MAAM,MAAM,EAAE,iBAAa,WAA6E,CAAA"}

package/dist/code.js

@@ -214,16 +214,29 @@ const startsWithIdentifierPattern = /^[A-Za-z_$]/;
 const startsWithNumberPattern = /^\d/;
 const startsWithCommentPattern = /^(?:#|--|\/[/*]|<!--)/;
 const startsWithStringPattern = /^["'`]/;
+const trimBlankEdgeLines = (lines) => {
+    let start = 0;
+    let end = lines.length;
+    while (start < end && lines[start]?.trim() === '')
+        start += 1;
+    while (end > start && lines[end - 1]?.trim() === '')
+        end -= 1;
+    return lines.slice(start, end);
+};
+const getMinimumIndent = (lines) => {
+    let minimum = Number.POSITIVE_INFINITY;
+    for (const line of lines) {
+        if (line.trim() === '')
+            continue;
+        const indent = leadingWhitespacePattern.exec(line)?.[0].length ?? 0;
+        if (indent < minimum)
+            minimum = indent;
+    }
+    return Number.isFinite(minimum) ? minimum : 0;
+};
 export const normalizeLumenCode = (code) => {
-    const lines = code.replaceAll(/\r\n?/g, '\n').split('\n');
-    while (lines[0]?.trim() === '')
-        lines.shift();
-    while (lines.at(-1)?.trim() === '')
-        lines.pop();
-    const indentation = lines
-        .filter(line => line.trim() !== '')
-        .map(line => leadingWhitespacePattern.exec(line)?.[0].length ?? 0);
-    const trimBy = indentation.length > 0 ? Math.min(...indentation) : 0;
+    const lines = trimBlankEdgeLines(code.replaceAll(/\r\n?/g, '\n').split('\n'));
+    const trimBy = getMinimumIndent(lines);
     return lines.map(line => line.slice(trimBy)).join('\n');
 };
 const getJavascriptTokenKind = (value) => {