chartjs-chart-treemap 5.0.0-next.8 → 5.0.0-next.9

package/dist/chartjs-chart-treemap.cjs

@@ -1,5 +1,5 @@
 /*!
- * chartjs-chart-treemap v5.0.0-next.8
+ * chartjs-chart-treemap v5.0.0-next.9
  * https://chartjs-chart-treemap.pages.dev/
  * (c) 2026 Jukka Kurkela
  * Released under the MIT license
@@ -10,7 +10,7 @@ typeof define === 'function' && define.amd ? define(['exports', 'chart.js', 'cha
 (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global["chartjs-chart-treemap"] = {}, global.Chart, global.Chart.helpers));
 })(this, (function (exports, chart_js, helpers) { 'use strict';
 
-var version = "5.0.0-next.8";
+var version = "5.0.0-next.9";
 
 function scaleRect(sq, xScale, yScale, sp) {
     const sp2 = sp * 2;
@@ -60,6 +60,14 @@ function parseBorderRadius(value, maxW, maxH) {
 
 function getDims(itm, w2, s2, key) {
     const a = itm._normalized;
+    if (!a) {
+        return {
+            d1: 0,
+            d2: 0,
+            h: 0,
+            w: 0
+        };
+    }
     const ar = w2 * a / s2;
     const d1 = Math.sqrt(a * ar);
     const d2 = a / d1;
@@ -427,6 +435,7 @@ function requireVersion(pkg, min, ver, strict = true) {
     return true;
 }
 
+const WEIGHT_KEY = '_weight';
 function compareAspectRatio(oldStat, newStat, args) {
     if (oldStat.sum === 0) {
         return true;
@@ -460,16 +469,17 @@ function compareAspectRatio(oldStat, newStat, args) {
         return node;
     });
 }
- function sortNodes(nodes) {
-    sort(nodes, 'v');
+ function sortNodes(nodes, weighted = false) {
+    sort(nodes, weighted ? WEIGHT_KEY : 'v');
 }
- function packInto(nodes, rectangle) {
+ function packInto(nodes, rectangle, weighted = false) {
     const n = nodes.length;
     if (!n) {
         return;
     }
+    const key = weighted ? WEIGHT_KEY : 'v';
     const rect = new Rect(rectangle);
-    const row = new StatArray('v', rect.area / sum(nodes, 'v'));
+    const row = new StatArray(key, rect.area / sum(nodes, key));
     let length = rect.side;
     let o;
     for(let i = 0; i < n; ++i){
@@ -488,47 +498,66 @@ function compareAspectRatio(oldStat, newStat, args) {
 
 const WIDTH_CACHE_LIMIT = 4096;
 const widthCache = new Map();
-function shouldDrawCaption(displayMode, rect, options) {
-    if (!options || options.display === false) {
-        return false;
-    }
-    if (displayMode === 'headerBoxes') {
-        return true;
+const fontFor = (fonts, index)=>fonts[Math.min(index, fonts.length - 1)];
+function measureLabelSize(ctx, lines, fonts) {
+    const fontsKey = fonts.reduce((prev, item)=>{
+        prev += item.string;
+        return prev;
+    }, '');
+    const mapKey = lines.join() + fontsKey + (ctx._measureText ? '-spriting' : '');
+    let size = widthCache.get(mapKey);
+    if (!size) {
+        ctx.save();
+        const count = lines.length;
+        let width = 0;
+        let height = 0;
+        for(let i = 0; i < count; i++){
+            const font = fonts[Math.min(i, fonts.length - 1)];
+            ctx.font = font.string;
+            const text = lines[i];
+            width = Math.max(width, ctx.measureText(text).width);
+            height += font.lineHeight;
+        }
+        ctx.restore();
+        size = {
+            height,
+            width
+        };
+        if (widthCache.size >= WIDTH_CACHE_LIMIT) {
+            widthCache.clear();
+        }
+        widthCache.set(mapKey, size);
     }
-    const { w, h } = rect;
-    const font = helpers.toFont(options.font || {});
-    const min = font.lineHeight;
-    const padding = Math.max(Math.min(helpers.valueOrDefault(options.padding, 3) * 2, Math.min(w, h)), 0);
-    return w - padding > min && h - padding > min;
+    return size;
 }
-function getCaptionHeight(displayMode, rect, font, padding) {
-    if (displayMode !== 'headerBoxes') {
-        return font.lineHeight + padding * 2;
-    }
-    const captionHeight = font.lineHeight + padding * 2;
-    return rect.h < 2 * captionHeight ? rect.h / 3 : captionHeight;
+function measureLines(ctx, lines, styles, fonts) {
+    let width = 0;
+    let height = 0;
+    lines.forEach((line, i)=>{
+        const font = fontFor(fonts, styles[i]);
+        width = Math.max(width, measureLabelSize(ctx, [
+            line
+        ], [
+            font
+        ]).width);
+        height += font.lineHeight;
+    });
+    return {
+        height,
+        width
+    };
 }
-function drawText(ctx, rect, options, item, element, layout) {
-    const { captions, labels } = options;
-    const { displayMode } = layout;
-    const isLeaf = item && (!helpers.defined(item.l) || item.isLeaf);
-    let block;
-    if (isLeaf) {
-        if (labels.display) {
-            block = labelBlock(ctx, rect, options, item, element);
-        }
-    } else if (shouldDrawCaption(displayMode, rect, captions)) {
-        block = captionBlock(ctx, rect, options, item, element, layout);
-    }
-    if (!block) {
-        return;
-    }
-    ctx.save();
-    clipToPadding(ctx, rect, block.padding, block.clipY);
-    drawTextBlock(ctx, rect, block);
-    ctx.restore();
+function toFonts(fonts, fitRatio) {
+    return fonts.map((f)=>{
+        const { lineHeight: _lineHeight, ...font } = f;
+        return helpers.toFont({
+            ...font,
+            size: Math.floor(f.size * fitRatio)
+        });
+    });
 }
- function clipToPadding(ctx, rect, padding, clipY) {
+
+function clipToPadding(ctx, rect, padding, clipY) {
     const x = Math.max(0, padding);
     const y = Math.max(0, clipY);
     ctx.beginPath();
@@ -551,134 +580,45 @@ function drawTextBlock(ctx, rect, block) {
         offset += font.lineHeight;
     });
 }
-function callbackContext(element, item) {
-    const context = element.$context || {
-        active: !!element.active,
-        raw: item,
-        type: 'data'
-    };
-    context.active = !!element.active;
-    context.raw = item;
-    return context;
-}
-function resolveOption(option, context) {
-    return typeof option === 'function' ? option(context) : option;
-}
-function resolveCaptionText(captions, element, item) {
-    return resolveOption(captions.formatter, callbackContext(element, item)) || item.g || '';
-}
- function captionText(ctx, rect, captions, element, item, fonts) {
-    const text = resolveCaptionText(captions, element, item);
-    if (!text) {
-        return undefined;
-    }
-    const padding = captions.padding;
-    if (measureLabelSize(ctx, [
-        text
-    ], fonts).width + 2 * padding <= rect.w) {
-        return text;
-    }
-    const overflow = captions.overflow || 'ellipsis';
-    if (overflow === 'hidden') {
-        return undefined;
+function calculateBlockTop(rect, options, labelSize) {
+    const { position, padding } = options;
+    if (position === 'top') {
+        return rect.y + padding;
     }
-    if (overflow === 'cut') {
-        return text;
+    if (position === 'bottom') {
+        return rect.y + rect.h - padding - labelSize.height;
     }
-    return sliceTextToFitWidth(ctx, text, rect.w - 2 * padding, fonts);
+    return rect.y + (rect.h - labelSize.height) / 2 + padding;
 }
-function captionBlock(ctx, rect, options, item, element, layout) {
-    const { displayMode, rtl, spacing } = layout;
-    const { captions } = options;
-    const { color, hoverColor, font, hoverFont, padding, align } = captions;
-    const optFont = (rect.active ? hoverFont : font) || font;
-    const oFont = helpers.toFont(optFont);
-    if (oFont.lineHeight > rect.h) {
-        return;
+ function calculateBlockLeft(rect, align, padding, width) {
+    if (align === 'left') {
+        return rect.x + padding;
     }
-    const text = captionText(ctx, rect, captions, element, item, [
-        oFont
-    ]);
-    if (text === undefined) {
-        return;
+    if (align === 'right') {
+        return rect.x + rect.w - padding - width;
     }
-    const fonts = [
-        oFont
-    ];
-    const top = displayMode === 'headerBoxes' ? rect.y + (rect.h - oFont.lineHeight) / 2 : rect.y + padding + spacing;
-    return {
-        align: align || (rtl ? 'right' : 'left'),
-        clipY: displayMode === 'headerBoxes' ? 0 : padding,
-        colors: [
-            (rect.active ? hoverColor : color) || color
-        ],
-        fonts,
-        lines: [
-            text
-        ],
-        padding,
-        styles: [
-            0
-        ],
-        textAlign: captions.textAlign,
-        top,
-        width: measureLabelSize(ctx, [
-            text
-        ], fonts).width
-    };
+    return rect.x + (rect.w - width) / 2;
 }
-function labelBlock(ctx, rect, options, item, element) {
-    const labels = options.labels;
-    const content = resolveOption(labels.formatter, callbackContext(element, item));
-    if (!content) {
-        return;
-    }
-    const { align, color, hoverColor, overflow, padding, wrap } = labels;
-    const maxWidth = rect.w - padding * 2;
-    const maxHeight = rect.h - padding * 2;
-    let fonts = getFontFromOptions(rect, labels);
-    let { lines, styles } = toLines(ctx, content, fonts, maxWidth, !!wrap);
-    let labelSize = measureLines(ctx, lines, styles, fonts);
-    const lblToDraw = labelToDraw(rect, labels, labelSize);
-    if (!lblToDraw) {
-        return;
-    }
-    if (helpers.isNumber(lblToDraw)) {
-        fonts = toFonts(fonts, lblToDraw);
-        if (wrap) {
-            const rewrapped = toLines(ctx, content, fonts, maxWidth, true);
-            lines = rewrapped.lines;
-            styles = rewrapped.styles;
-            labelSize = measureLines(ctx, lines, styles, fonts);
-        } else {
-            labelSize = {
-                height: labelSize.height * lblToDraw,
-                width: labelSize.width * lblToDraw
-            };
+function calculateLineX(rect, align, lineAlign, padding, width) {
+    if (align === lineAlign) {
+        if (align === 'left') {
+            return rect.x + padding;
+        }
+        if (align === 'right') {
+            return rect.x + rect.w - padding;
         }
+        return rect.x + rect.w / 2;
     }
-    if (overflow === 'ellipsis') {
-        const trimmed = applyEllipsis(ctx, lines, styles, fonts, maxWidth, maxHeight);
-        lines = trimmed.lines;
-        styles = trimmed.styles;
-        labelSize = measureLines(ctx, lines, styles, fonts);
+    const left = calculateBlockLeft(rect, align, padding, width);
+    if (lineAlign === 'left') {
+        return left;
     }
-    const optColor = (rect.active ? hoverColor : color) || color;
-    return {
-        align,
-        clipY: padding,
-        colors: helpers.isArray(optColor) ? optColor : [
-            optColor
-        ],
-        fonts,
-        lines,
-        padding,
-        styles,
-        textAlign: labels.textAlign,
-        top: calculateBlockTop(rect, labels, labelSize),
-        width: labelSize.width
-    };
+    if (lineAlign === 'right') {
+        return left + width;
+    }
+    return left + width / 2;
 }
+
 function sliceTextToFitWidth(ctx, text, width, fonts) {
     const ellipsis = '...';
     const ellipsisWidth = measureLabelSize(ctx, [
@@ -705,14 +645,60 @@ function sliceTextToFitWidth(ctx, text, width, fonts) {
     const slicedText = text.slice(0, Math.max(0, lowerBoundLen - 1));
     return slicedText ? slicedText + ellipsis : '';
 }
-const fontFor = (fonts, index)=>fonts[Math.min(index, fonts.length - 1)];
- function wrapToWidth(ctx, text, font, width) {
-    if (width <= 0) {
-        return [
-            text
-        ];
+function applyEllipsis(ctx, lines, styles, fonts, maxWidth, maxHeight) {
+    const keptLines = [];
+    const keptStyles = [];
+    let used = 0;
+    for(let i = 0; i < lines.length; i++){
+        const font = fontFor(fonts, styles[i]);
+        if (keptLines.length && used + font.lineHeight > maxHeight) {
+            break;
+        }
+        used += font.lineHeight;
+        keptLines.push(lines[i]);
+        keptStyles.push(styles[i]);
     }
-    const fits = (value)=>measureLabelSize(ctx, [
+    const dropped = keptLines.length < lines.length;
+    const last = keptLines.length - 1;
+    for(let i = 0; i < keptLines.length; i++){
+        const font = fontFor(fonts, keptStyles[i]);
+        const tooWide = measureLabelSize(ctx, [
+            keptLines[i]
+        ], [
+            font
+        ]).width > maxWidth;
+        if (tooWide || dropped && i === last) {
+            keptLines[i] = sliceTextToFitWidth(ctx, keptLines[i], maxWidth, [
+                font
+            ]);
+        }
+    }
+    return {
+        lines: keptLines,
+        styles: keptStyles
+    };
+}
+function labelToDraw(rect, options, labelSize) {
+    const { overflow, padding } = options;
+    const { width, height } = labelSize;
+    if (overflow === 'hidden') {
+        return !(width + padding * 2 > rect.w || height + padding * 2 > rect.h);
+    } else if (overflow === 'fit') {
+        const ratio = Math.min(rect.w / (width + padding * 2), rect.h / (height + padding * 2));
+        if (ratio < 1) {
+            return ratio;
+        }
+    }
+    return true;
+}
+
+function wrapToWidth(ctx, text, font, width) {
+    if (width <= 0) {
+        return [
+            text
+        ];
+    }
+    const fits = (value)=>measureLabelSize(ctx, [
             value
         ], [
             font
@@ -753,7 +739,7 @@ const fontFor = (fonts, index)=>fonts[Math.min(index, fonts.length - 1)];
         ''
     ];
 }
- function toLines(ctx, content, fonts, width, wrap) {
+function toLines(ctx, content, fonts, width, wrap) {
     const paragraphs = (helpers.isArray(content) ? content : [
         content
     ]).map((entry)=>`${entry}`);
@@ -775,168 +761,193 @@ const fontFor = (fonts, index)=>fonts[Math.min(index, fonts.length - 1)];
         styles
     };
 }
- function measureLines(ctx, lines, styles, fonts) {
-    let width = 0;
-    let height = 0;
-    lines.forEach((line, i)=>{
-        const font = fontFor(fonts, styles[i]);
-        width = Math.max(width, measureLabelSize(ctx, [
-            line
-        ], [
-            font
-        ]).width);
-        height += font.lineHeight;
-    });
-    return {
-        height,
-        width
-    };
+
+function shouldDrawCaption(displayMode, rect, options) {
+    if (!options || options.display === false) {
+        return false;
+    }
+    if (displayMode === 'headerBoxes') {
+        return true;
+    }
+    const { w, h } = rect;
+    const font = helpers.toFont(options.font || {});
+    const min = font.lineHeight;
+    const padding = Math.max(Math.min(helpers.valueOrDefault(options.padding, 3) * 2, Math.min(w, h)), 0);
+    return w - padding > min && h - padding > min;
 }
- function applyEllipsis(ctx, lines, styles, fonts, maxWidth, maxHeight) {
-    const keptLines = [];
-    const keptStyles = [];
-    let used = 0;
-    for(let i = 0; i < lines.length; i++){
-        const font = fontFor(fonts, styles[i]);
-        if (keptLines.length && used + font.lineHeight > maxHeight) {
-            break;
-        }
-        used += font.lineHeight;
-        keptLines.push(lines[i]);
-        keptStyles.push(styles[i]);
+function getCaptionHeight(displayMode, rect, font, padding) {
+    if (displayMode !== 'headerBoxes') {
+        return font.lineHeight + padding * 2;
     }
-    const dropped = keptLines.length < lines.length;
-    const last = keptLines.length - 1;
-    for(let i = 0; i < keptLines.length; i++){
-        const font = fontFor(fonts, keptStyles[i]);
-        const tooWide = measureLabelSize(ctx, [
-            keptLines[i]
-        ], [
-            font
-        ]).width > maxWidth;
-        if (tooWide || dropped && i === last) {
-            keptLines[i] = sliceTextToFitWidth(ctx, keptLines[i], maxWidth, [
-                font
-            ]);
+    const captionHeight = font.lineHeight + padding * 2;
+    return rect.h < 2 * captionHeight ? rect.h / 3 : captionHeight;
+}
+function drawText(ctx, rect, options, item, element, layout) {
+    const { captions, labels } = options;
+    const { displayMode } = layout;
+    const isLeaf = item && (!helpers.defined(item.l) || item.isLeaf);
+    let block;
+    if (isLeaf) {
+        if (labels.display) {
+            block = labelBlock(ctx, rect, options, item, element);
         }
+    } else if (shouldDrawCaption(displayMode, rect, captions)) {
+        block = captionBlock(ctx, rect, options, item, element, layout);
     }
-    return {
-        lines: keptLines,
-        styles: keptStyles
+    if (!block) {
+        return;
+    }
+    ctx.save();
+    clipToPadding(ctx, rect, block.padding, block.clipY);
+    drawTextBlock(ctx, rect, block);
+    ctx.restore();
+}
+function callbackContext(element, item) {
+    const context = element.$context || {
+        active: !!element.active,
+        raw: item,
+        type: 'data'
     };
+    context.active = !!element.active;
+    context.raw = item;
+    return context;
 }
-function measureLabelSize(ctx, lines, fonts) {
-    const fontsKey = fonts.reduce((prev, item)=>{
-        prev += item.string;
-        return prev;
-    }, '');
-    const mapKey = lines.join() + fontsKey + (ctx._measureText ? '-spriting' : '');
-    let size = widthCache.get(mapKey);
-    if (!size) {
-        ctx.save();
-        const count = lines.length;
-        let width = 0;
-        let height = 0;
-        for(let i = 0; i < count; i++){
-            const font = fonts[Math.min(i, fonts.length - 1)];
-            ctx.font = font.string;
-            const text = lines[i];
-            width = Math.max(width, ctx.measureText(text).width);
-            height += font.lineHeight;
-        }
-        ctx.restore();
-        size = {
-            height,
-            width
-        };
-        if (widthCache.size >= WIDTH_CACHE_LIMIT) {
-            widthCache.clear();
-        }
-        widthCache.set(mapKey, size);
-    }
-    return size;
+function resolveOption(option, context) {
+    return typeof option === 'function' ? option(context) : option;
 }
-function toFonts(fonts, fitRatio) {
-    return fonts.map((f)=>{
-        const { lineHeight: _lineHeight, ...font } = f;
-        return helpers.toFont({
-            ...font,
-            size: Math.floor(f.size * fitRatio)
-        });
-    });
+function resolveCaptionText(captions, element, item) {
+    return resolveOption(captions.formatter, callbackContext(element, item)) || item.g || '';
 }
-function labelToDraw(rect, options, labelSize) {
-    const { overflow, padding } = options;
-    const { width, height } = labelSize;
+ function captionText(ctx, rect, captions, element, item, fonts) {
+    const text = resolveCaptionText(captions, element, item);
+    if (!text) {
+        return undefined;
+    }
+    const padding = captions.padding;
+    if (measureLabelSize(ctx, [
+        text
+    ], fonts).width + 2 * padding <= rect.w) {
+        return text;
+    }
+    const overflow = captions.overflow || 'ellipsis';
     if (overflow === 'hidden') {
-        return !(width + padding * 2 > rect.w || height + padding * 2 > rect.h);
-    } else if (overflow === 'fit') {
-        const ratio = Math.min(rect.w / (width + padding * 2), rect.h / (height + padding * 2));
-        if (ratio < 1) {
-            return ratio;
-        }
+        return undefined;
     }
-    return true;
+    if (overflow === 'cut') {
+        return text;
+    }
+    return sliceTextToFitWidth(ctx, text, rect.w - 2 * padding, fonts);
 }
-function getFontFromOptions(rect, labels) {
-    const { font, hoverFont } = labels;
+function captionBlock(ctx, rect, options, item, element, layout) {
+    const { displayMode, rtl, spacing } = layout;
+    const { captions } = options;
+    const { color, hoverColor, font, hoverFont, padding, align } = captions;
     const optFont = (rect.active ? hoverFont : font) || font;
-    return Array.isArray(optFont) ? optFont.map((f)=>helpers.toFont(f)) : [
-        helpers.toFont(optFont)
-    ];
-}
-function calculateBlockTop(rect, options, labelSize) {
-    const { position, padding } = options;
-    if (position === 'top') {
-        return rect.y + padding;
+    const oFont = helpers.toFont(optFont);
+    if (oFont.lineHeight > rect.h) {
+        return;
     }
-    if (position === 'bottom') {
-        return rect.y + rect.h - padding - labelSize.height;
+    const text = captionText(ctx, rect, captions, element, item, [
+        oFont
+    ]);
+    if (text === undefined) {
+        return;
     }
-    return rect.y + (rect.h - labelSize.height) / 2 + padding;
+    const fonts = [
+        oFont
+    ];
+    const top = displayMode === 'headerBoxes' ? rect.y + (rect.h - oFont.lineHeight) / 2 : rect.y + padding + spacing;
+    return {
+        align: align || (rtl ? 'right' : 'left'),
+        clipY: displayMode === 'headerBoxes' ? 0 : padding,
+        colors: [
+            (rect.active ? hoverColor : color) || color
+        ],
+        fonts,
+        lines: [
+            text
+        ],
+        padding,
+        styles: [
+            0
+        ],
+        textAlign: captions.textAlign,
+        top,
+        width: measureLabelSize(ctx, [
+            text
+        ], fonts).width
+    };
 }
- function calculateBlockLeft(rect, align, padding, width) {
-    if (align === 'left') {
-        return rect.x + padding;
+function labelBlock(ctx, rect, options, item, element) {
+    const labels = options.labels;
+    const content = resolveOption(labels.formatter, callbackContext(element, item));
+    if (!content) {
+        return;
     }
-    if (align === 'right') {
-        return rect.x + rect.w - padding - width;
+    const { align, color, hoverColor, overflow, padding, wrap } = labels;
+    const maxWidth = rect.w - padding * 2;
+    const maxHeight = rect.h - padding * 2;
+    let fonts = getFontFromOptions(rect, labels);
+    let { lines, styles } = toLines(ctx, content, fonts, maxWidth, !!wrap);
+    let labelSize = measureLines(ctx, lines, styles, fonts);
+    const lblToDraw = labelToDraw(rect, labels, labelSize);
+    if (!lblToDraw) {
+        return;
     }
-    return rect.x + (rect.w - width) / 2;
-}
- function calculateLineX(rect, align, lineAlign, padding, width) {
-    if (align === lineAlign) {
-        if (align === 'left') {
-            return rect.x + padding;
-        }
-        if (align === 'right') {
-            return rect.x + rect.w - padding;
+    if (helpers.isNumber(lblToDraw)) {
+        fonts = toFonts(fonts, lblToDraw);
+        if (wrap) {
+            const rewrapped = toLines(ctx, content, fonts, maxWidth, true);
+            lines = rewrapped.lines;
+            styles = rewrapped.styles;
+            labelSize = measureLines(ctx, lines, styles, fonts);
+        } else {
+            labelSize = {
+                height: labelSize.height * lblToDraw,
+                width: labelSize.width * lblToDraw
+            };
         }
-        return rect.x + rect.w / 2;
     }
-    const left = calculateBlockLeft(rect, align, padding, width);
-    if (lineAlign === 'left') {
-        return left;
-    }
-    if (lineAlign === 'right') {
-        return left + width;
+    if (overflow === 'ellipsis') {
+        const trimmed = applyEllipsis(ctx, lines, styles, fonts, maxWidth, maxHeight);
+        lines = trimmed.lines;
+        styles = trimmed.styles;
+        labelSize = measureLines(ctx, lines, styles, fonts);
     }
-    return left + width / 2;
+    const optColor = (rect.active ? hoverColor : color) || color;
+    return {
+        align,
+        clipY: padding,
+        colors: helpers.isArray(optColor) ? optColor : [
+            optColor
+        ],
+        fonts,
+        lines,
+        padding,
+        styles,
+        textAlign: labels.textAlign,
+        top: calculateBlockTop(rect, labels, labelSize),
+        width: labelSize.width
+    };
+}
+function getFontFromOptions(rect, labels) {
+    const { font, hoverFont } = labels;
+    const optFont = (rect.active ? hoverFont : font) || font;
+    return Array.isArray(optFont) ? optFont.map((f)=>helpers.toFont(f)) : [
+        helpers.toFont(optFont)
+    ];
 }
 
-function buildHierarchy(values, gidx, keys, layout, parentGroupValue) {
+function buildHierarchy(values, gidx, keys, layout, weighted, parentGroupValue) {
     const { groups, leafKey, unsorted } = layout;
     const glen = groups.length;
     const g = getGroupKey(groups[gidx]);
     const gdata = group(values, g, keys, leafKey, undefined, parentGroupValue, groups.filter((_item, index)=>index <= gidx), groups, gidx);
     const nodes = toNodes(gdata, keys, g, gidx);
-    if (!unsorted) {
-        sortNodes(nodes);
-    }
     for (const node of nodes){
         const record = node._data;
         const nextGroupIndex = record.groupIndex + 1;
-        const children = gidx < glen - 1 && nextGroupIndex < glen ? buildHierarchy(record.children, nextGroupIndex, keys, layout, node.g) : [];
+        const children = gidx < glen - 1 && nextGroupIndex < glen ? buildHierarchy(record.children, nextGroupIndex, keys, layout, weighted, node.g) : [];
         Object.defineProperty(node, '_children', {
             configurable: true,
             value: children,
@@ -944,8 +955,91 @@ function buildHierarchy(values, gidx, keys, layout, parentGroupValue) {
         });
         node.isLeaf = !children.length;
     }
-    return nodes;
+    if (weighted) {
+        applyValueScale(nodes, scaleFor(layout));
+    }
+    const withOthers = layout.others ? applyOthers(nodes, layout.others, weighted) : nodes;
+    if (!unsorted) {
+        sortNodes(withOthers, weighted);
+    }
+    return withOthers;
+}
+ function applyValueScale(nodes, scale) {
+    for (const node of nodes){
+        const children = node._children;
+        let weight;
+        if (children?.length) {
+            applyValueScale(children, scale);
+            weight = children.reduce((total, child)=>total + child[WEIGHT_KEY], 0);
+        } else {
+            const scaled = scale(node.v, node._data);
+            weight = Number.isFinite(scaled) && scaled > 0 ? scaled : 0;
+        }
+        Object.defineProperty(node, WEIGHT_KEY, {
+            configurable: true,
+            value: weight,
+            writable: true
+        });
+    }
+}
+ function applyOthers(nodes, others, weighted) {
+    const { label = 'Other', minCount = 2, threshold } = others;
+    if (!(threshold > 0) || nodes.some((node)=>node._children?.length)) {
+        return nodes;
+    }
+    const weightOf = (node)=>weighted ? node[WEIGHT_KEY] : node.v;
+    const total = nodes.reduce((sum, node)=>sum + weightOf(node), 0);
+    if (!(total > 0)) {
+        return nodes;
+    }
+    const small = nodes.filter((node)=>weightOf(node) / total < threshold);
+    if (small.length < Math.max(2, minCount)) {
+        return nodes;
+    }
+    const kept = nodes.filter((node)=>!small.includes(node));
+    const bucket = {
+        _data: {
+            label,
+            others: small.map((node)=>node._data)
+        },
+        h: 0,
+        isLeaf: true,
+        isOthers: true,
+        s: 0,
+        v: small.reduce((sum, node)=>sum + node.v, 0),
+        vs: sumValues(small),
+        w: 0,
+        x: 0,
+        y: 0
+    };
+    const grouped = nodes.find((node)=>node.g !== undefined);
+    if (grouped) {
+        bucket.g = label;
+        bucket.l = grouped.l;
+    }
+    if (weighted) {
+        Object.defineProperty(bucket, WEIGHT_KEY, {
+            configurable: true,
+            value: small.reduce((sum, node)=>sum + weightOf(node), 0),
+            writable: true
+        });
+    }
+    kept.push(bucket);
+    return kept;
 }
+ function sumValues(nodes) {
+    const totals = {};
+    for (const node of nodes){
+        for (const [key, value] of Object.entries(node.vs || {})){
+            totals[key] = (totals[key] || 0) + value;
+        }
+    }
+    return Object.keys(totals).length ? totals : undefined;
+}
+const VALUE_SCALES = {
+    log: (value)=>Math.log1p(Math.max(value, 0)),
+    sqrt: (value)=>Math.sqrt(Math.max(value, 0))
+};
  function flattenNodes(nodes) {
     const flat = nodes.slice();
     for (const node of nodes){
@@ -955,22 +1049,33 @@ function buildHierarchy(values, gidx, keys, layout, parentGroupValue) {
     }
     return flat;
 }
- function layoutLevel(nodes, rect, layout, parentSum) {
+ function layoutLevel(nodes, rect, layout, weighted, parentSum) {
     if (parentSum !== undefined) {
         for (const node of nodes){
             node.gs = parentSum;
         }
     }
-    packInto(nodes, rect);
+    packInto(nodes, rect, weighted);
     for (const node of nodes){
         if (node._children?.length) {
-            layoutLevel(node._children, getSubRect(node, rect, layout), layout, node.s);
+            layoutLevel(node._children, getSubRect(node, rect, layout), layout, weighted, node.s);
         }
     }
 }
  function layoutNodes(nodes, rect, layout) {
-    layoutLevel(nodes, rect, layout);
+    layoutLevel(nodes, rect, layout, isWeighted(layout));
     applyHeaderBoxes(flattenNodes(nodes), layout);
+}
+ function isWeighted(layout) {
+    const scale = layout.valueScale;
+    return scale !== 'linear' && scale !== undefined;
+}
+function scaleFor(layout) {
+    const scale = layout.valueScale;
+    if (typeof scale === 'function') {
+        return scale;
+    }
+    return VALUE_SCALES[scale] || ((value)=>value);
 }
  function getSubRect(sq, rect, layout) {
     const { borderWidth, captions, displayMode } = layout;
@@ -998,12 +1103,21 @@ function buildHierarchy(values, gidx, keys, layout, parentGroupValue) {
  function buildNodes(tree, keys, layout) {
     const { groups, leafKey, unsorted } = layout;
     const input = helpers.isObject(tree) ? normalizeTreeToArray(keys, leafKey, tree) : tree;
+    const weighted = isWeighted(layout);
+    let nodes;
     if (groups.length) {
-        return buildHierarchy(input, 0, keys, layout);
-    }
-    const nodes = toNodes(input || [], keys);
-    if (!unsorted) {
-        sortNodes(nodes);
+        nodes = buildHierarchy(input, 0, keys, layout, weighted);
+    } else {
+        nodes = toNodes(input || [], keys);
+        if (weighted) {
+            applyValueScale(nodes, scaleFor(layout));
+        }
+        if (layout.others) {
+            nodes = applyOthers(nodes, layout.others, weighted);
+        }
+        if (!unsorted) {
+            sortNodes(nodes, weighted);
+        }
     }
     return nodes;
 }
@@ -1027,6 +1141,9 @@ function buildHierarchy(values, gidx, keys, layout, parentGroupValue) {
     }
 }
 
+function clampFraction(value, fallback) {
+    return value === undefined ? fallback : Math.min(Math.max(value, 0), 1);
+}
 function registerTooltipPositioner() {
     const tooltipPlugin = chart_js.registry.plugins.get('tooltip');
     if (!tooltipPlugin || tooltipPlugin.positioners.treemap) {
@@ -1061,12 +1178,9 @@ class TreemapController extends chart_js.DatasetController {
         const w = xScale.right - xScale.left;
         const h = yScale.bottom - yScale.top;
         const rect = {
-            h,
+            ...this._regionBounds(w, h),
             rtl: !!this.options.rtl,
-            unsorted: !!this.options.unsorted,
-            w,
-            x: 0,
-            y: 0
+            unsorted: !!this.options.unsorted
         };
         if (rectNotEqual(this._rect, rect)) {
             this._rect = rect;
@@ -1079,6 +1193,31 @@ class TreemapController extends chart_js.DatasetController {
             yScale.configure();
         }
     }
+ _regionBounds(w, h) {
+        const region = this.options.region;
+        if (!region) {
+            return {
+                h,
+                w,
+                x: 0,
+                y: 0
+            };
+        }
+        const left = clampFraction(region.left, 0);
+        const top = clampFraction(region.top, 0);
+        const width = clampFraction(region.width, 1);
+        const height = clampFraction(region.height, 1);
+        if (!this._regionWarned && (left + width > 1 || top + height > 1)) {
+            this._regionWarned = true;
+            console.warn('chartjs-chart-treemap: a dataset region reaches outside the chart area and is clipped to it.');
+        }
+        return {
+            h: h * Math.min(height, 1 - top),
+            w: w * Math.min(width, 1 - left),
+            x: w * left,
+            y: h * top
+        };
+    }
  _layoutOptions() {
         const dataset = this.getDataset();
         const options = this.options;
@@ -1088,8 +1227,10 @@ class TreemapController extends chart_js.DatasetController {
             displayMode: options.displayMode,
             groups: options.groups || [],
             leafKey: options.leafKey,
+            others: options.others || false,
             spacing: helpers.valueOrDefault(dataset.spacing, 0),
-            unsorted: !!options.unsorted
+            unsorted: !!options.unsorted,
+            valueScale: options.valueScale || 'linear'
         };
     }
  buildOrUpdateElements(_resetNewElements) {
@@ -1144,8 +1285,10 @@ class TreemapController extends chart_js.DatasetController {
         }
         const dataset = this.getDataset();
         const label = node.g ?? node._data?.label ?? dataset.label;
+        const text = label === undefined ? '' : `${label}`;
+        const others = node.isOthers ? node._data?.others?.length : undefined;
         return {
-            label: label === undefined ? '' : `${label}`,
+            label: others ? `${text} (${others} items)` : text,
             value: `${node.v}`
         };
     }
@@ -1207,6 +1350,7 @@ class TreemapController extends chart_js.DatasetController {
         super(chart, datasetIndex);
         this._rect = undefined;
         this._rectChanged = true;
+        this._regionWarned = false;
         this._nodes = [];
         this._layoutDirty = true;
         this._fingerprint = undefined;
@@ -1231,10 +1375,13 @@ TreemapController.defaults = {
     groups: [],
     key: '',
     leafKey: '_leaf',
+    others: false,
+    region: undefined,
     rtl: layoutDefaults.rtl,
     spacing: layoutDefaults.spacing,
     sumKeys: [],
-    unsorted: false
+    unsorted: false,
+    valueScale: 'linear'
 };
 TreemapController.descriptors = {
     _indexable: false,