handsontable 0.0.0-next-21f0f43-20250210 → 0.0.0-next-8951d31-20250210

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Potentially problematic release.


This version of handsontable might be problematic. Click here for more details.

@@ -300,16 +300,6 @@ class Table {
300
300
  this.resetOversizedRows();
301
301
  this.tableRenderer.setActiveOverlayName(this.name).setViewportSize(this.getRenderedRowsCount(), this.getRenderedColumnsCount()).setFilters(this.rowFilter, this.columnFilter).render();
302
302
  if (this.isMaster) {
303
- this.markOversizedColumnHeaders();
304
- }
305
- this.adjustColumnHeaderHeights();
306
- if (this.isMaster || this.is(_overlay.CLONE_BOTTOM)) {
307
- this.markOversizedRows();
308
- }
309
- if (this.isMaster) {
310
- if (!this.wtSettings.getSetting('externalRowCalculator')) {
311
- wtViewport.createVisibleCalculators();
312
- }
313
303
  wtOverlays.refresh(false);
314
304
  wtOverlays.applyToDOM();
315
305
  this.wtSettings.getSetting('onDraw', true);
@@ -351,85 +341,18 @@ class Table {
351
341
  /**
352
342
  * @param {number} col The visual column index.
353
343
  */
354
- markIfOversizedColumnHeader(col) {
355
- const sourceColIndex = this.columnFilter.renderedToSource(col);
356
- let level = this.wtSettings.getSetting('columnHeaders').length;
357
- const defaultRowHeight = this.dataAccessObject.stylesHandler.getDefaultRowHeight();
358
- let previousColHeaderHeight;
359
- let currentHeader;
360
- let currentHeaderHeight;
361
- const columnHeaderHeightSetting = this.wtSettings.getSetting('columnHeaderHeight') || [];
362
- while (level) {
363
- level -= 1;
364
- previousColHeaderHeight = this.getColumnHeaderHeight(level);
365
- currentHeader = this.getColumnHeader(sourceColIndex, level);
366
- if (!currentHeader) {
367
- /* eslint-disable no-continue */
368
- continue;
369
- }
370
- currentHeaderHeight = (0, _element.innerHeight)(currentHeader);
371
- if (!previousColHeaderHeight && defaultRowHeight < currentHeaderHeight || previousColHeaderHeight < currentHeaderHeight) {
372
- this.dataAccessObject.wtViewport.oversizedColumnHeaders[level] = currentHeaderHeight;
373
- }
374
- if (Array.isArray(columnHeaderHeightSetting)) {
375
- if (columnHeaderHeightSetting[level] !== null && columnHeaderHeightSetting[level] !== undefined) {
376
- this.dataAccessObject.wtViewport.oversizedColumnHeaders[level] = columnHeaderHeightSetting[level];
377
- }
378
- } else if (!isNaN(columnHeaderHeightSetting)) {
379
- this.dataAccessObject.wtViewport.oversizedColumnHeaders[level] = columnHeaderHeightSetting;
380
- }
381
- if (this.dataAccessObject.wtViewport.oversizedColumnHeaders[level] < (columnHeaderHeightSetting[level] || columnHeaderHeightSetting)) {
382
- this.dataAccessObject.wtViewport.oversizedColumnHeaders[level] = columnHeaderHeightSetting[level] || columnHeaderHeightSetting; // eslint-disable-line max-len
383
- }
384
- }
385
- }
344
+ markIfOversizedColumnHeader(col) {}
386
345
 
387
346
  /**
388
347
  *
389
348
  */
390
- adjustColumnHeaderHeights() {
391
- const {
392
- wtSettings
393
- } = this;
394
- const children = this.THEAD.childNodes;
395
- const oversizedColumnHeaders = this.dataAccessObject.wtViewport.oversizedColumnHeaders;
396
- const columnHeaders = wtSettings.getSetting('columnHeaders');
397
- for (let i = 0, len = columnHeaders.length; i < len; i++) {
398
- if (oversizedColumnHeaders[i]) {
399
- if (!children[i] || children[i].childNodes.length === 0) {
400
- return;
401
- }
402
- children[i].childNodes[0].style.height = `${oversizedColumnHeaders[i]}px`;
403
- }
404
- }
405
- }
349
+ adjustColumnHeaderHeights() {}
406
350
 
407
351
  /**
408
352
  * Resets cache of row heights. The cache should be cached for each render cycle in a case
409
353
  * when new cell values have content which increases/decreases cell height.
410
354
  */
411
- resetOversizedRows() {
412
- const {
413
- wtSettings
414
- } = this;
415
- const {
416
- wtViewport
417
- } = this.dataAccessObject;
418
- if (!this.isMaster && !this.is(_overlay.CLONE_BOTTOM)) {
419
- return;
420
- }
421
- if (!wtSettings.getSetting('externalRowCalculator')) {
422
- const rowsToRender = this.getRenderedRowsCount();
423
-
424
- // Reset the oversized row cache for rendered rows
425
- for (let visibleRowIndex = 0; visibleRowIndex < rowsToRender; visibleRowIndex++) {
426
- const sourceRow = this.rowFilter.renderedToSource(visibleRowIndex);
427
- if (wtViewport.oversizedRows && wtViewport.oversizedRows[sourceRow]) {
428
- wtViewport.oversizedRows[sourceRow] = undefined;
429
- }
430
- }
431
- }
432
- }
355
+ resetOversizedRows() {}
433
356
 
434
357
  /**
435
358
  * Get cell element at coords.
@@ -627,46 +550,7 @@ class Table {
627
550
  /**
628
551
  * Check if any of the rendered rows is higher than expected, and if so, cache them.
629
552
  */
630
- markOversizedRows() {
631
- if (this.wtSettings.getSetting('externalRowCalculator')) {
632
- return;
633
- }
634
- let rowCount = this.TBODY.childNodes.length;
635
- const expectedTableHeight = rowCount * this.dataAccessObject.stylesHandler.getDefaultRowHeight();
636
- const actualTableHeight = (0, _element.innerHeight)(this.TBODY) - 1;
637
- const borderBoxSizing = this.wot.stylesHandler.areCellsBorderBox();
638
- const rowHeightFn = borderBoxSizing ? _element.outerHeight : _element.innerHeight;
639
- const borderCompensation = borderBoxSizing ? 0 : 1;
640
- const firstRowBorderCompensation = borderBoxSizing ? 1 : 0;
641
- let previousRowHeight;
642
- let rowCurrentHeight;
643
- let sourceRowIndex;
644
- let currentTr;
645
- let rowHeader;
646
- if (expectedTableHeight === actualTableHeight && !this.wtSettings.getSetting('fixedRowsBottom')) {
647
- // If the actual table height equals rowCount * default single row height, no row is oversized -> no need to iterate over them
648
- return;
649
- }
650
- while (rowCount) {
651
- rowCount -= 1;
652
- sourceRowIndex = this.rowFilter.renderedToSource(rowCount);
653
- previousRowHeight = this.getRowHeight(sourceRowIndex);
654
- currentTr = this.getTrForRow(sourceRowIndex);
655
- rowHeader = currentTr.querySelector('th');
656
- const topBorderCompensation = sourceRowIndex === 0 ? firstRowBorderCompensation : 0;
657
- if (rowHeader) {
658
- rowCurrentHeight = rowHeightFn(rowHeader);
659
- } else {
660
- rowCurrentHeight = rowHeightFn(currentTr) - borderCompensation;
661
- }
662
- if (!previousRowHeight && this.dataAccessObject.stylesHandler.getDefaultRowHeight() < rowCurrentHeight - topBorderCompensation || previousRowHeight < rowCurrentHeight) {
663
- if (!borderBoxSizing) {
664
- rowCurrentHeight += 1;
665
- }
666
- this.dataAccessObject.wtViewport.oversizedRows[sourceRowIndex] = rowCurrentHeight;
667
- }
668
- }
669
- }
553
+ markOversizedRows() {}
670
554
 
671
555
  /**
672
556
  * @param {number} row The visual row index.
@@ -981,32 +865,7 @@ class Table {
981
865
  * @returns {number}
982
866
  */
983
867
  _modifyRowHeaderWidth(rowHeaderWidthFactory) {
984
- let widths = (0, _function.isFunction)(rowHeaderWidthFactory) ? rowHeaderWidthFactory() : null;
985
- if (Array.isArray(widths)) {
986
- widths = [...widths];
987
- widths[widths.length - 1] = this._correctRowHeaderWidth(widths[widths.length - 1]);
988
- } else {
989
- widths = this._correctRowHeaderWidth(widths);
990
- }
991
- return widths;
992
- }
993
-
994
- /**
995
- * Correct row header width if necessary.
996
- *
997
- * @private
998
- * @param {number} width The width to process.
999
- * @returns {number}
1000
- */
1001
- _correctRowHeaderWidth(width) {
1002
- let rowHeaderWidth = width;
1003
- if (typeof width !== 'number') {
1004
- rowHeaderWidth = this.wtSettings.getSetting('defaultColumnWidth');
1005
- }
1006
- if (this.correctHeaderWidth) {
1007
- rowHeaderWidth += 1;
1008
- }
1009
- return rowHeaderWidth;
868
+ return 50;
1010
869
  }
1011
870
  }
1012
871
  var _default = exports.default = Table;
@@ -296,16 +296,6 @@ class Table {
296
296
  this.resetOversizedRows();
297
297
  this.tableRenderer.setActiveOverlayName(this.name).setViewportSize(this.getRenderedRowsCount(), this.getRenderedColumnsCount()).setFilters(this.rowFilter, this.columnFilter).render();
298
298
  if (this.isMaster) {
299
- this.markOversizedColumnHeaders();
300
- }
301
- this.adjustColumnHeaderHeights();
302
- if (this.isMaster || this.is(CLONE_BOTTOM)) {
303
- this.markOversizedRows();
304
- }
305
- if (this.isMaster) {
306
- if (!this.wtSettings.getSetting('externalRowCalculator')) {
307
- wtViewport.createVisibleCalculators();
308
- }
309
299
  wtOverlays.refresh(false);
310
300
  wtOverlays.applyToDOM();
311
301
  this.wtSettings.getSetting('onDraw', true);
@@ -347,85 +337,18 @@ class Table {
347
337
  /**
348
338
  * @param {number} col The visual column index.
349
339
  */
350
- markIfOversizedColumnHeader(col) {
351
- const sourceColIndex = this.columnFilter.renderedToSource(col);
352
- let level = this.wtSettings.getSetting('columnHeaders').length;
353
- const defaultRowHeight = this.dataAccessObject.stylesHandler.getDefaultRowHeight();
354
- let previousColHeaderHeight;
355
- let currentHeader;
356
- let currentHeaderHeight;
357
- const columnHeaderHeightSetting = this.wtSettings.getSetting('columnHeaderHeight') || [];
358
- while (level) {
359
- level -= 1;
360
- previousColHeaderHeight = this.getColumnHeaderHeight(level);
361
- currentHeader = this.getColumnHeader(sourceColIndex, level);
362
- if (!currentHeader) {
363
- /* eslint-disable no-continue */
364
- continue;
365
- }
366
- currentHeaderHeight = innerHeight(currentHeader);
367
- if (!previousColHeaderHeight && defaultRowHeight < currentHeaderHeight || previousColHeaderHeight < currentHeaderHeight) {
368
- this.dataAccessObject.wtViewport.oversizedColumnHeaders[level] = currentHeaderHeight;
369
- }
370
- if (Array.isArray(columnHeaderHeightSetting)) {
371
- if (columnHeaderHeightSetting[level] !== null && columnHeaderHeightSetting[level] !== undefined) {
372
- this.dataAccessObject.wtViewport.oversizedColumnHeaders[level] = columnHeaderHeightSetting[level];
373
- }
374
- } else if (!isNaN(columnHeaderHeightSetting)) {
375
- this.dataAccessObject.wtViewport.oversizedColumnHeaders[level] = columnHeaderHeightSetting;
376
- }
377
- if (this.dataAccessObject.wtViewport.oversizedColumnHeaders[level] < (columnHeaderHeightSetting[level] || columnHeaderHeightSetting)) {
378
- this.dataAccessObject.wtViewport.oversizedColumnHeaders[level] = columnHeaderHeightSetting[level] || columnHeaderHeightSetting; // eslint-disable-line max-len
379
- }
380
- }
381
- }
340
+ markIfOversizedColumnHeader(col) {}
382
341
 
383
342
  /**
384
343
  *
385
344
  */
386
- adjustColumnHeaderHeights() {
387
- const {
388
- wtSettings
389
- } = this;
390
- const children = this.THEAD.childNodes;
391
- const oversizedColumnHeaders = this.dataAccessObject.wtViewport.oversizedColumnHeaders;
392
- const columnHeaders = wtSettings.getSetting('columnHeaders');
393
- for (let i = 0, len = columnHeaders.length; i < len; i++) {
394
- if (oversizedColumnHeaders[i]) {
395
- if (!children[i] || children[i].childNodes.length === 0) {
396
- return;
397
- }
398
- children[i].childNodes[0].style.height = `${oversizedColumnHeaders[i]}px`;
399
- }
400
- }
401
- }
345
+ adjustColumnHeaderHeights() {}
402
346
 
403
347
  /**
404
348
  * Resets cache of row heights. The cache should be cached for each render cycle in a case
405
349
  * when new cell values have content which increases/decreases cell height.
406
350
  */
407
- resetOversizedRows() {
408
- const {
409
- wtSettings
410
- } = this;
411
- const {
412
- wtViewport
413
- } = this.dataAccessObject;
414
- if (!this.isMaster && !this.is(CLONE_BOTTOM)) {
415
- return;
416
- }
417
- if (!wtSettings.getSetting('externalRowCalculator')) {
418
- const rowsToRender = this.getRenderedRowsCount();
419
-
420
- // Reset the oversized row cache for rendered rows
421
- for (let visibleRowIndex = 0; visibleRowIndex < rowsToRender; visibleRowIndex++) {
422
- const sourceRow = this.rowFilter.renderedToSource(visibleRowIndex);
423
- if (wtViewport.oversizedRows && wtViewport.oversizedRows[sourceRow]) {
424
- wtViewport.oversizedRows[sourceRow] = undefined;
425
- }
426
- }
427
- }
428
- }
351
+ resetOversizedRows() {}
429
352
 
430
353
  /**
431
354
  * Get cell element at coords.
@@ -623,46 +546,7 @@ class Table {
623
546
  /**
624
547
  * Check if any of the rendered rows is higher than expected, and if so, cache them.
625
548
  */
626
- markOversizedRows() {
627
- if (this.wtSettings.getSetting('externalRowCalculator')) {
628
- return;
629
- }
630
- let rowCount = this.TBODY.childNodes.length;
631
- const expectedTableHeight = rowCount * this.dataAccessObject.stylesHandler.getDefaultRowHeight();
632
- const actualTableHeight = innerHeight(this.TBODY) - 1;
633
- const borderBoxSizing = this.wot.stylesHandler.areCellsBorderBox();
634
- const rowHeightFn = borderBoxSizing ? outerHeight : innerHeight;
635
- const borderCompensation = borderBoxSizing ? 0 : 1;
636
- const firstRowBorderCompensation = borderBoxSizing ? 1 : 0;
637
- let previousRowHeight;
638
- let rowCurrentHeight;
639
- let sourceRowIndex;
640
- let currentTr;
641
- let rowHeader;
642
- if (expectedTableHeight === actualTableHeight && !this.wtSettings.getSetting('fixedRowsBottom')) {
643
- // If the actual table height equals rowCount * default single row height, no row is oversized -> no need to iterate over them
644
- return;
645
- }
646
- while (rowCount) {
647
- rowCount -= 1;
648
- sourceRowIndex = this.rowFilter.renderedToSource(rowCount);
649
- previousRowHeight = this.getRowHeight(sourceRowIndex);
650
- currentTr = this.getTrForRow(sourceRowIndex);
651
- rowHeader = currentTr.querySelector('th');
652
- const topBorderCompensation = sourceRowIndex === 0 ? firstRowBorderCompensation : 0;
653
- if (rowHeader) {
654
- rowCurrentHeight = rowHeightFn(rowHeader);
655
- } else {
656
- rowCurrentHeight = rowHeightFn(currentTr) - borderCompensation;
657
- }
658
- if (!previousRowHeight && this.dataAccessObject.stylesHandler.getDefaultRowHeight() < rowCurrentHeight - topBorderCompensation || previousRowHeight < rowCurrentHeight) {
659
- if (!borderBoxSizing) {
660
- rowCurrentHeight += 1;
661
- }
662
- this.dataAccessObject.wtViewport.oversizedRows[sourceRowIndex] = rowCurrentHeight;
663
- }
664
- }
665
- }
549
+ markOversizedRows() {}
666
550
 
667
551
  /**
668
552
  * @param {number} row The visual row index.
@@ -977,32 +861,7 @@ class Table {
977
861
  * @returns {number}
978
862
  */
979
863
  _modifyRowHeaderWidth(rowHeaderWidthFactory) {
980
- let widths = isFunction(rowHeaderWidthFactory) ? rowHeaderWidthFactory() : null;
981
- if (Array.isArray(widths)) {
982
- widths = [...widths];
983
- widths[widths.length - 1] = this._correctRowHeaderWidth(widths[widths.length - 1]);
984
- } else {
985
- widths = this._correctRowHeaderWidth(widths);
986
- }
987
- return widths;
988
- }
989
-
990
- /**
991
- * Correct row header width if necessary.
992
- *
993
- * @private
994
- * @param {number} width The width to process.
995
- * @returns {number}
996
- */
997
- _correctRowHeaderWidth(width) {
998
- let rowHeaderWidth = width;
999
- if (typeof width !== 'number') {
1000
- rowHeaderWidth = this.wtSettings.getSetting('defaultColumnWidth');
1001
- }
1002
- if (this.correctHeaderWidth) {
1003
- rowHeaderWidth += 1;
1004
- }
1005
- return rowHeaderWidth;
864
+ return 50;
1006
865
  }
1007
866
  }
1008
867
  export default Table;
@@ -24,7 +24,6 @@ class Viewport {
24
24
  this.domBindings = domBindings;
25
25
  this.wtSettings = wtSettings;
26
26
  this.wtTable = wtTable;
27
- this.oversizedRows = [];
28
27
  this.oversizedColumnHeaders = [];
29
28
  this.hasOversizedColumnHeadersMarked = {};
30
29
  this.clientHeight = 0;
@@ -179,47 +178,14 @@ class Viewport {
179
178
  * @returns {number}
180
179
  */
181
180
  getColumnHeaderHeight() {
182
- const columnHeaders = this.wtSettings.getSetting('columnHeaders');
183
- if (!columnHeaders.length) {
184
- this.columnHeaderHeight = 0;
185
- } else if (isNaN(this.columnHeaderHeight)) {
186
- this.columnHeaderHeight = (0, _element.outerHeight)(this.wtTable.THEAD);
187
- }
188
- return this.columnHeaderHeight;
181
+ return 59;
189
182
  }
190
183
 
191
184
  /**
192
185
  * @returns {number}
193
186
  */
194
187
  getRowHeaderWidth() {
195
- const rowHeadersWidthSetting = this.wtSettings.getSetting('rowHeaderWidth');
196
- const rowHeaders = this.wtSettings.getSetting('rowHeaders');
197
- if (rowHeadersWidthSetting) {
198
- this.rowHeaderWidth = 0;
199
- for (let i = 0, len = rowHeaders.length; i < len; i++) {
200
- this.rowHeaderWidth += rowHeadersWidthSetting[i] || rowHeadersWidthSetting;
201
- }
202
- }
203
- if (isNaN(this.rowHeaderWidth)) {
204
- if (rowHeaders.length) {
205
- let TH = this.wtTable.TABLE.querySelector('TH');
206
- this.rowHeaderWidth = 0;
207
- for (let i = 0, len = rowHeaders.length; i < len; i++) {
208
- if (TH) {
209
- this.rowHeaderWidth += (0, _element.outerWidth)(TH);
210
- TH = TH.nextSibling;
211
- } else {
212
- // yes this is a cheat but it worked like that before, just taking assumption from CSS instead of measuring.
213
- // TODO: proper fix
214
- this.rowHeaderWidth += 50;
215
- }
216
- }
217
- } else {
218
- this.rowHeaderWidth = 0;
219
- }
220
- }
221
- this.rowHeaderWidth = this.wtSettings.getSetting('onModifyRowHeaderWidth', this.rowHeaderWidth) || this.rowHeaderWidth;
222
- return this.rowHeaderWidth;
188
+ return 50;
223
189
  }
224
190
 
225
191
  /**
@@ -21,7 +21,6 @@ class Viewport {
21
21
  this.domBindings = domBindings;
22
22
  this.wtSettings = wtSettings;
23
23
  this.wtTable = wtTable;
24
- this.oversizedRows = [];
25
24
  this.oversizedColumnHeaders = [];
26
25
  this.hasOversizedColumnHeadersMarked = {};
27
26
  this.clientHeight = 0;
@@ -176,47 +175,14 @@ class Viewport {
176
175
  * @returns {number}
177
176
  */
178
177
  getColumnHeaderHeight() {
179
- const columnHeaders = this.wtSettings.getSetting('columnHeaders');
180
- if (!columnHeaders.length) {
181
- this.columnHeaderHeight = 0;
182
- } else if (isNaN(this.columnHeaderHeight)) {
183
- this.columnHeaderHeight = outerHeight(this.wtTable.THEAD);
184
- }
185
- return this.columnHeaderHeight;
178
+ return 59;
186
179
  }
187
180
 
188
181
  /**
189
182
  * @returns {number}
190
183
  */
191
184
  getRowHeaderWidth() {
192
- const rowHeadersWidthSetting = this.wtSettings.getSetting('rowHeaderWidth');
193
- const rowHeaders = this.wtSettings.getSetting('rowHeaders');
194
- if (rowHeadersWidthSetting) {
195
- this.rowHeaderWidth = 0;
196
- for (let i = 0, len = rowHeaders.length; i < len; i++) {
197
- this.rowHeaderWidth += rowHeadersWidthSetting[i] || rowHeadersWidthSetting;
198
- }
199
- }
200
- if (isNaN(this.rowHeaderWidth)) {
201
- if (rowHeaders.length) {
202
- let TH = this.wtTable.TABLE.querySelector('TH');
203
- this.rowHeaderWidth = 0;
204
- for (let i = 0, len = rowHeaders.length; i < len; i++) {
205
- if (TH) {
206
- this.rowHeaderWidth += outerWidth(TH);
207
- TH = TH.nextSibling;
208
- } else {
209
- // yes this is a cheat but it worked like that before, just taking assumption from CSS instead of measuring.
210
- // TODO: proper fix
211
- this.rowHeaderWidth += 50;
212
- }
213
- }
214
- } else {
215
- this.rowHeaderWidth = 0;
216
- }
217
- }
218
- this.rowHeaderWidth = this.wtSettings.getSetting('onModifyRowHeaderWidth', this.rowHeaderWidth) || this.rowHeaderWidth;
219
- return this.rowHeaderWidth;
185
+ return 50;
220
186
  }
221
187
 
222
188
  /**
package/base.js CHANGED
@@ -45,8 +45,8 @@ Handsontable.hooks = _hooks.Hooks.getSingleton();
45
45
  Handsontable.CellCoords = _src.CellCoords;
46
46
  Handsontable.CellRange = _src.CellRange;
47
47
  Handsontable.packageName = 'handsontable';
48
- Handsontable.buildDate = "10/02/2025 10:14:07";
49
- Handsontable.version = "0.0.0-next-21f0f43-20250210";
48
+ Handsontable.buildDate = "10/02/2025 11:00:12";
49
+ Handsontable.version = "0.0.0-next-8951d31-20250210";
50
50
  Handsontable.languages = {
51
51
  dictionaryKeys: _registry.dictionaryKeys,
52
52
  getLanguageDictionary: _registry.getLanguageDictionary,
package/base.mjs CHANGED
@@ -35,8 +35,8 @@ Handsontable.hooks = Hooks.getSingleton();
35
35
  Handsontable.CellCoords = CellCoords;
36
36
  Handsontable.CellRange = CellRange;
37
37
  Handsontable.packageName = 'handsontable';
38
- Handsontable.buildDate = "10/02/2025 10:14:12";
39
- Handsontable.version = "0.0.0-next-21f0f43-20250210";
38
+ Handsontable.buildDate = "10/02/2025 11:00:18";
39
+ Handsontable.version = "0.0.0-next-8951d31-20250210";
40
40
  Handsontable.languages = {
41
41
  dictionaryKeys,
42
42
  getLanguageDictionary,
@@ -25,8 +25,8 @@
25
25
  * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER ARISING FROM
26
26
  * USE OR INABILITY TO USE THIS SOFTWARE.
27
27
  *
28
- * Version: 0.0.0-next-21f0f43-20250210
29
- * Release date: 16/12/2024 (built at 10/02/2025 10:14:34)
28
+ * Version: 0.0.0-next-8951d31-20250210
29
+ * Release date: 16/12/2024 (built at 10/02/2025 11:00:39)
30
30
  */
31
31
  /**
32
32
  * Fix for bootstrap styles
@@ -25,8 +25,8 @@
25
25
  * INDIRECT, SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES OF ANY CHARACTER ARISING FROM
26
26
  * USE OR INABILITY TO USE THIS SOFTWARE.
27
27
  *
28
- * Version: 0.0.0-next-21f0f43-20250210
29
- * Release date: 16/12/2024 (built at 10/02/2025 10:14:34)
28
+ * Version: 0.0.0-next-8951d31-20250210
29
+ * Release date: 16/12/2024 (built at 10/02/2025 11:00:39)
30
30
  */
31
31
  /**
32
32
  * Fix for bootstrap styles