handsontable 18.0.0 → 18.1.0-rc7

package/utils/samplesGenerator.d.ts

@@ -11,10 +11,15 @@ type SampleEntry = {
         row?: number;
     }>;
 };
+type SampleRange = {
+    from: number;
+    to: number;
+} | number[];
 /**
  * @class SamplesGenerator
  */
 declare class SamplesGenerator {
+    #private;
     /**
      * Number of samples to take of each value length.
      *
@@ -87,41 +92,63 @@ declare class SamplesGenerator {
      * Generate samples for row. You can control which area should be sampled by passing `rowRange` object and `colRange` object.
      *
      * @param {object|number} rowRange The rows range to generate the samples.
-     * @param {object} colRange The column range to generate the samples.
+     * @param {object|number[]} colRange The column range (or an explicit list of column indexes) to generate the samples.
      * @returns {object}
      */
-    generateRowSamples(rowRange: unknown, colRange: unknown): Map<any, any>;
+    generateRowSamples(rowRange: number | {
+        from: number;
+        to: number;
+    }, colRange: SampleRange): Map<any, any>;
     /**
      * Generate samples for column. You can control which area should be sampled by passing `colRange` object and `rowRange` object.
      *
-     * @param {object} colRange Column index.
-     * @param {object} rowRange Column index.
+     * @param {object|number} colRange The columns range to generate the samples.
+     * @param {object|number[]} rowRange The row range (or an explicit list of row indexes) to generate the samples.
      * @returns {object}
      */
-    generateColumnSamples(colRange: unknown, rowRange: unknown): Map<any, any>;
+    generateColumnSamples(colRange: number | {
+        from: number;
+        to: number;
+    }, rowRange: SampleRange): Map<any, any>;
     /**
      * Generate collection of samples.
      *
      * @param {string} type Type to generate. Can be `col` or `row`.
-     * @param {object} range The range to generate the samples.
+     * @param {object|number[]} range The range (or an explicit list of indexes) to generate the samples.
      * @param {object|number} specifierRange The range to generate the samples.
      * @returns {Map}
      */
-    generateSamples(type: string, range: {
+    generateSamples(type: string, range: SampleRange, specifierRange: number | {
         from: number;
         to: number;
-    }, specifierRange: unknown): Map<any, any>;
+    }): Map<any, any>;
     /**
      * Generate sample for specified type (`row` or `col`).
      *
+     * When `existingSamples` is provided, the new samples are accumulated into it instead of a fresh
+     * map. This lets callers sweep a large range in slices (e.g. one slice per animation frame)
+     * while keeping the per-bucket sample limits and the duplicate detection working across slices.
+     *
      * @param {string} type Samples type `row` or `col`.
-     * @param {object} range The range to generate the samples.
-     * @param {number} specifierValue The range to generate the samples.
+     * @param {object|number[]} range The range (or an explicit list of indexes) to generate the samples.
+     * @param {number} specifierValue The row (for `row` type) or column (for `col` type) index to sample.
+     * @param {Map} [existingSamples] A samples map from a previous call to accumulate into.
      * @returns {Map}
      */
-    generateSample(type: string, range: {
-        from: number;
-        to: number;
-    }, specifierValue: number): Map<string | undefined, SampleEntry>;
+    generateSample(type: string, range: SampleRange, specifierValue: number, existingSamples?: Map<string, SampleEntry>): Map<string, SampleEntry>;
+    /**
+     * Generates one samples map from already-known values, bypassing the data factory. Used to
+     * bucket-and-cap values that can no longer be read from the data source (e.g. the previous
+     * cell values carried by a change batch).
+     *
+     * @param {string} type Samples type `row` or `col`.
+     * @param {Array} entries An array of `{ index, value }` objects, where `index` is the
+     * opposite-axis index the value belongs to (a row index for `col` type samples).
+     * @returns {Map}
+     */
+    generateSampleFromValues(type: string, entries: Array<{
+        index: number;
+        value: unknown;
+    }>): Map<string, SampleEntry>;
 }
 export default SamplesGenerator;

package/utils/samplesGenerator.js

@@ -12,6 +12,36 @@ const _object = require("./../helpers/object");
 const _errors = require("../helpers/errors");
 const _number = require("./../helpers/number");
 const _mixed = require("./../helpers/mixed");
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
+var /**
+   * Throws when the sample type is not one of the supported `row`/`col` values.
+   *
+   * @param {string} type Samples type to validate.
+   */ _ensureSupportedType = /*#__PURE__*/ new WeakSet(), /**
+   * Buckets a single value into the samples map, respecting the per-bucket sample limit and
+   * the duplicate detection.
+   *
+   * @param {Map} samples The samples map to collect into.
+   * @param {Array} sampledValues Values collected so far (across the whole sweep), used for duplicate detection.
+   * @param {string} computedKey The key (`row` or `col`) under which the index is stored in the sample string.
+   * @param {number} index The opposite-axis index the value belongs to.
+   * @param {*} value The value to bucket.
+   * @param {string|undefined} bundleSeed A custom bucket seed provided by the data factory.
+   */ _collectSample = /*#__PURE__*/ new WeakSet();
 /**
  * @class SamplesGenerator
  */ class SamplesGenerator {
@@ -57,7 +87,7 @@ const _mixed = require("./../helpers/mixed");
    * Generate samples for row. You can control which area should be sampled by passing `rowRange` object and `colRange` object.
    *
    * @param {object|number} rowRange The rows range to generate the samples.
-   * @param {object} colRange The column range to generate the samples.
+   * @param {object|number[]} colRange The column range (or an explicit list of column indexes) to generate the samples.
    * @returns {object}
    */ generateRowSamples(rowRange, colRange) {
         return this.generateSamples('row', colRange, rowRange);
@@ -65,8 +95,8 @@ const _mixed = require("./../helpers/mixed");
     /**
    * Generate samples for column. You can control which area should be sampled by passing `colRange` object and `rowRange` object.
    *
-   * @param {object} colRange Column index.
-   * @param {object} rowRange Column index.
+   * @param {object|number} colRange The columns range to generate the samples.
+   * @param {object|number[]} rowRange The row range (or an explicit list of row indexes) to generate the samples.
    * @returns {object}
    */ generateColumnSamples(colRange, rowRange) {
         return this.generateSamples('col', rowRange, colRange);
@@ -75,7 +105,7 @@ const _mixed = require("./../helpers/mixed");
    * Generate collection of samples.
    *
    * @param {string} type Type to generate. Can be `col` or `row`.
-   * @param {object} range The range to generate the samples.
+   * @param {object|number[]} range The range (or an explicit list of indexes) to generate the samples.
    * @param {object|number} specifierRange The range to generate the samples.
    * @returns {Map}
    */ generateSamples(type, range, specifierRange) {
@@ -93,58 +123,63 @@ const _mixed = require("./../helpers/mixed");
     /**
    * Generate sample for specified type (`row` or `col`).
    *
+   * When `existingSamples` is provided, the new samples are accumulated into it instead of a fresh
+   * map. This lets callers sweep a large range in slices (e.g. one slice per animation frame)
+   * while keeping the per-bucket sample limits and the duplicate detection working across slices.
+   *
    * @param {string} type Samples type `row` or `col`.
-   * @param {object} range The range to generate the samples.
-   * @param {number} specifierValue The range to generate the samples.
+   * @param {object|number[]} range The range (or an explicit list of indexes) to generate the samples.
+   * @param {number} specifierValue The row (for `row` type) or column (for `col` type) index to sample.
+   * @param {Map} [existingSamples] A samples map from a previous call to accumulate into.
    * @returns {Map}
-   */ generateSample(type, range, specifierValue) {
-        if (type !== 'row' && type !== 'col') {
-            (0, _errors.throwWithCause)('Unsupported sample type');
-        }
-        const samples = new Map();
+   */ generateSample(type, range, specifierValue, existingSamples) {
+        _class_private_method_get(this, _ensureSupportedType, ensureSupportedType).call(this, type);
+        const samples = existingSamples ?? new Map();
         const computedKey = type === 'row' ? 'col' : 'row';
         const sampledValues = [];
-        (0, _number.rangeEach)(range.from, range.to, (index)=>{
+        if (existingSamples) {
+            existingSamples.forEach((sample)=>{
+                sample.strings.forEach(({ value })=>sampledValues.push(value));
+            });
+        }
+        const collect = (index)=>{
             const data = type === 'row' ? this.dataFactory(specifierValue, index, this) : this.dataFactory(index, specifierValue, this);
             if (data === false) {
                 return;
             }
-            const { value, bundleSeed } = data;
-            const hasCustomBundleSeed = typeof bundleSeed === 'string' && bundleSeed.length > 0;
-            let seed;
-            if (hasCustomBundleSeed) {
-                seed = bundleSeed;
-            } else if ((0, _object.isPlainObject)(value)) {
-                seed = `${Object.keys(value).length}`;
-            } else if (Array.isArray(value)) {
-                seed = `${value.length}`;
-            } else {
-                seed = `${(0, _mixed.stringify)(value).length}`;
-            }
-            if (!samples.has(seed)) {
-                samples.set(seed, {
-                    needed: this.getSampleCount(),
-                    strings: []
-                });
-            }
-            const sample = samples.get(seed);
-            if (sample && sample.needed) {
-                const duplicate = sampledValues.indexOf(value) > -1;
-                if (!duplicate || this.allowDuplicates || hasCustomBundleSeed) {
-                    sample.strings.push({
-                        value,
-                        [computedKey]: index
-                    });
-                    sampledValues.push(value);
-                    sample.needed -= 1;
-                }
-            }
+            _class_private_method_get(this, _collectSample, collectSample).call(this, samples, sampledValues, computedKey, index, data.value, data.bundleSeed);
+        };
+        if (Array.isArray(range)) {
+            range.forEach(collect);
+        } else {
+            (0, _number.rangeEach)(range.from, range.to, collect);
+        }
+        return samples;
+    }
+    /**
+   * Generates one samples map from already-known values, bypassing the data factory. Used to
+   * bucket-and-cap values that can no longer be read from the data source (e.g. the previous
+   * cell values carried by a change batch).
+   *
+   * @param {string} type Samples type `row` or `col`.
+   * @param {Array} entries An array of `{ index, value }` objects, where `index` is the
+   * opposite-axis index the value belongs to (a row index for `col` type samples).
+   * @returns {Map}
+   */ generateSampleFromValues(type, entries) {
+        _class_private_method_get(this, _ensureSupportedType, ensureSupportedType).call(this, type);
+        const samples = new Map();
+        const computedKey = type === 'row' ? 'col' : 'row';
+        const sampledValues = [];
+        entries.forEach(({ index, value })=>{
+            _class_private_method_get(this, _collectSample, collectSample).call(this, samples, sampledValues, computedKey, index, value, undefined);
         });
         return samples;
     }
     /**
    * Initializes the samples generator with the data factory function used to retrieve cell values during sampling.
    */ constructor(dataFactory){
+        _class_private_method_init(this, _ensureSupportedType);
+        _class_private_method_init(this, _collectSample);
         /**
    * Samples prepared for calculations.
    *
@@ -177,4 +212,41 @@ const _mixed = require("./../helpers/mixed");
         this.dataFactory = dataFactory;
     }
 }
+function ensureSupportedType(type) {
+    if (type !== 'row' && type !== 'col') {
+        (0, _errors.throwWithCause)('Unsupported sample type');
+    }
+}
+function collectSample(samples, sampledValues, computedKey, index, value, bundleSeed) {
+    const customBundleSeed = typeof bundleSeed === 'string' && bundleSeed.length > 0 ? bundleSeed : null;
+    const hasCustomBundleSeed = customBundleSeed !== null;
+    let seed;
+    if (customBundleSeed !== null) {
+        seed = customBundleSeed;
+    } else if ((0, _object.isPlainObject)(value)) {
+        seed = `${Object.keys(value).length}`;
+    } else if (Array.isArray(value)) {
+        seed = `${value.length}`;
+    } else {
+        seed = `${(0, _mixed.stringify)(value).length}`;
+    }
+    if (!samples.has(seed)) {
+        samples.set(seed, {
+            needed: this.getSampleCount(),
+            strings: []
+        });
+    }
+    const sample = samples.get(seed);
+    if (sample && sample.needed) {
+        const duplicate = sampledValues.indexOf(value) > -1;
+        if (!duplicate || this.allowDuplicates || hasCustomBundleSeed) {
+            sample.strings.push({
+                value,
+                [computedKey]: index
+            });
+            sampledValues.push(value);
+            sample.needed -= 1;
+        }
+    }
+}
 const _default = SamplesGenerator;

package/utils/samplesGenerator.mjs

@@ -1,7 +1,37 @@
+function _check_private_redeclaration(obj, privateCollection) {
+    if (privateCollection.has(obj)) {
+        throw new TypeError("Cannot initialize the same private elements twice on an object");
+    }
+}
+function _class_private_method_get(receiver, privateSet, fn) {
+    if (!privateSet.has(receiver)) {
+        throw new TypeError("attempted to get private field on non-instance");
+    }
+    return fn;
+}
+function _class_private_method_init(obj, privateSet) {
+    _check_private_redeclaration(obj, privateSet);
+    privateSet.add(obj);
+}
 import { isPlainObject } from './../helpers/object.mjs';
 import { throwWithCause } from '../helpers/errors.mjs';
 import { rangeEach } from './../helpers/number.mjs';
 import { stringify } from './../helpers/mixed.mjs';
+var /**
+   * Throws when the sample type is not one of the supported `row`/`col` values.
+   *
+   * @param {string} type Samples type to validate.
+   */ _ensureSupportedType = /*#__PURE__*/ new WeakSet(), /**
+   * Buckets a single value into the samples map, respecting the per-bucket sample limit and
+   * the duplicate detection.
+   *
+   * @param {Map} samples The samples map to collect into.
+   * @param {Array} sampledValues Values collected so far (across the whole sweep), used for duplicate detection.
+   * @param {string} computedKey The key (`row` or `col`) under which the index is stored in the sample string.
+   * @param {number} index The opposite-axis index the value belongs to.
+   * @param {*} value The value to bucket.
+   * @param {string|undefined} bundleSeed A custom bucket seed provided by the data factory.
+   */ _collectSample = /*#__PURE__*/ new WeakSet();
 /**
  * @class SamplesGenerator
  */ class SamplesGenerator {
@@ -47,7 +77,7 @@ import { stringify } from './../helpers/mixed.mjs';
    * Generate samples for row. You can control which area should be sampled by passing `rowRange` object and `colRange` object.
    *
    * @param {object|number} rowRange The rows range to generate the samples.
-   * @param {object} colRange The column range to generate the samples.
+   * @param {object|number[]} colRange The column range (or an explicit list of column indexes) to generate the samples.
    * @returns {object}
    */ generateRowSamples(rowRange, colRange) {
         return this.generateSamples('row', colRange, rowRange);
@@ -55,8 +85,8 @@ import { stringify } from './../helpers/mixed.mjs';
     /**
    * Generate samples for column. You can control which area should be sampled by passing `colRange` object and `rowRange` object.
    *
-   * @param {object} colRange Column index.
-   * @param {object} rowRange Column index.
+   * @param {object|number} colRange The columns range to generate the samples.
+   * @param {object|number[]} rowRange The row range (or an explicit list of row indexes) to generate the samples.
    * @returns {object}
    */ generateColumnSamples(colRange, rowRange) {
         return this.generateSamples('col', rowRange, colRange);
@@ -65,7 +95,7 @@ import { stringify } from './../helpers/mixed.mjs';
    * Generate collection of samples.
    *
    * @param {string} type Type to generate. Can be `col` or `row`.
-   * @param {object} range The range to generate the samples.
+   * @param {object|number[]} range The range (or an explicit list of indexes) to generate the samples.
    * @param {object|number} specifierRange The range to generate the samples.
    * @returns {Map}
    */ generateSamples(type, range, specifierRange) {
@@ -83,58 +113,63 @@ import { stringify } from './../helpers/mixed.mjs';
     /**
    * Generate sample for specified type (`row` or `col`).
    *
+   * When `existingSamples` is provided, the new samples are accumulated into it instead of a fresh
+   * map. This lets callers sweep a large range in slices (e.g. one slice per animation frame)
+   * while keeping the per-bucket sample limits and the duplicate detection working across slices.
+   *
    * @param {string} type Samples type `row` or `col`.
-   * @param {object} range The range to generate the samples.
-   * @param {number} specifierValue The range to generate the samples.
+   * @param {object|number[]} range The range (or an explicit list of indexes) to generate the samples.
+   * @param {number} specifierValue The row (for `row` type) or column (for `col` type) index to sample.
+   * @param {Map} [existingSamples] A samples map from a previous call to accumulate into.
    * @returns {Map}
-   */ generateSample(type, range, specifierValue) {
-        if (type !== 'row' && type !== 'col') {
-            throwWithCause('Unsupported sample type');
-        }
-        const samples = new Map();
+   */ generateSample(type, range, specifierValue, existingSamples) {
+        _class_private_method_get(this, _ensureSupportedType, ensureSupportedType).call(this, type);
+        const samples = existingSamples ?? new Map();
         const computedKey = type === 'row' ? 'col' : 'row';
         const sampledValues = [];
-        rangeEach(range.from, range.to, (index)=>{
+        if (existingSamples) {
+            existingSamples.forEach((sample)=>{
+                sample.strings.forEach(({ value })=>sampledValues.push(value));
+            });
+        }
+        const collect = (index)=>{
             const data = type === 'row' ? this.dataFactory(specifierValue, index, this) : this.dataFactory(index, specifierValue, this);
             if (data === false) {
                 return;
             }
-            const { value, bundleSeed } = data;
-            const hasCustomBundleSeed = typeof bundleSeed === 'string' && bundleSeed.length > 0;
-            let seed;
-            if (hasCustomBundleSeed) {
-                seed = bundleSeed;
-            } else if (isPlainObject(value)) {
-                seed = `${Object.keys(value).length}`;
-            } else if (Array.isArray(value)) {
-                seed = `${value.length}`;
-            } else {
-                seed = `${stringify(value).length}`;
-            }
-            if (!samples.has(seed)) {
-                samples.set(seed, {
-                    needed: this.getSampleCount(),
-                    strings: []
-                });
-            }
-            const sample = samples.get(seed);
-            if (sample && sample.needed) {
-                const duplicate = sampledValues.indexOf(value) > -1;
-                if (!duplicate || this.allowDuplicates || hasCustomBundleSeed) {
-                    sample.strings.push({
-                        value,
-                        [computedKey]: index
-                    });
-                    sampledValues.push(value);
-                    sample.needed -= 1;
-                }
-            }
+            _class_private_method_get(this, _collectSample, collectSample).call(this, samples, sampledValues, computedKey, index, data.value, data.bundleSeed);
+        };
+        if (Array.isArray(range)) {
+            range.forEach(collect);
+        } else {
+            rangeEach(range.from, range.to, collect);
+        }
+        return samples;
+    }
+    /**
+   * Generates one samples map from already-known values, bypassing the data factory. Used to
+   * bucket-and-cap values that can no longer be read from the data source (e.g. the previous
+   * cell values carried by a change batch).
+   *
+   * @param {string} type Samples type `row` or `col`.
+   * @param {Array} entries An array of `{ index, value }` objects, where `index` is the
+   * opposite-axis index the value belongs to (a row index for `col` type samples).
+   * @returns {Map}
+   */ generateSampleFromValues(type, entries) {
+        _class_private_method_get(this, _ensureSupportedType, ensureSupportedType).call(this, type);
+        const samples = new Map();
+        const computedKey = type === 'row' ? 'col' : 'row';
+        const sampledValues = [];
+        entries.forEach(({ index, value })=>{
+            _class_private_method_get(this, _collectSample, collectSample).call(this, samples, sampledValues, computedKey, index, value, undefined);
         });
         return samples;
     }
     /**
    * Initializes the samples generator with the data factory function used to retrieve cell values during sampling.
    */ constructor(dataFactory){
+        _class_private_method_init(this, _ensureSupportedType);
+        _class_private_method_init(this, _collectSample);
         /**
    * Samples prepared for calculations.
    *
@@ -167,4 +202,41 @@ import { stringify } from './../helpers/mixed.mjs';
         this.dataFactory = dataFactory;
     }
 }
+function ensureSupportedType(type) {
+    if (type !== 'row' && type !== 'col') {
+        throwWithCause('Unsupported sample type');
+    }
+}
+function collectSample(samples, sampledValues, computedKey, index, value, bundleSeed) {
+    const customBundleSeed = typeof bundleSeed === 'string' && bundleSeed.length > 0 ? bundleSeed : null;
+    const hasCustomBundleSeed = customBundleSeed !== null;
+    let seed;
+    if (customBundleSeed !== null) {
+        seed = customBundleSeed;
+    } else if (isPlainObject(value)) {
+        seed = `${Object.keys(value).length}`;
+    } else if (Array.isArray(value)) {
+        seed = `${value.length}`;
+    } else {
+        seed = `${stringify(value).length}`;
+    }
+    if (!samples.has(seed)) {
+        samples.set(seed, {
+            needed: this.getSampleCount(),
+            strings: []
+        });
+    }
+    const sample = samples.get(seed);
+    if (sample && sample.needed) {
+        const duplicate = sampledValues.indexOf(value) > -1;
+        if (!duplicate || this.allowDuplicates || hasCustomBundleSeed) {
+            sample.strings.push({
+                value,
+                [computedKey]: index
+            });
+            sampledValues.push(value);
+            sample.needed -= 1;
+        }
+    }
+}
 export default SamplesGenerator;

package/utils/sanitizer.d.mts

@@ -0,0 +1 @@
+export * from './sanitizer.js';

package/utils/sanitizer.d.ts

@@ -0,0 +1,47 @@
+import type { HotInstance } from '../core/types';
+import type { SanitizerContext, SanitizerFn } from '../core/settings';
+/**
+ * Re-exported for the plugins that hold a resolved sanitizer (`dialog`, `notification`).
+ *
+ * Treat this as reachable by consumers, not sealed. The published `exports` map has no `./utils/*`
+ * entry, but that only blocks subpath resolution under `node16` and `bundler`; classic
+ * `moduleResolution: node` ignores `exports` entirely, and `tmp/utils/sanitizer.d.ts` is shipped
+ * with no `files` field trimming it. So renaming or narrowing what this module exports can break a
+ * consumer. `SanitizerContext` is published from `handsontable` itself, which is where users should
+ * take it from.
+ */
+export type { SanitizerFn } from '../core/settings';
+/**
+ * Reads the grid-level `sanitizer` option in the form `fastInnerHTML` expects.
+ *
+ * Every call site that writes cell or header content through `fastInnerHTML` goes through this
+ * helper, so they cannot drift apart on the fallback value or on how the option is looked up.
+ * `true` is the fallback, which makes `fastInnerHTML` write raw HTML and warn once.
+ *
+ * The `html` cell type and `allowHtml` autocomplete sources deliberately do not use this helper:
+ * they render raw HTML by design (see PR #7368) and pass `false` instead.
+ *
+ * @param {object} hot The Handsontable instance.
+ * @returns {boolean|Function} The configured sanitizer, or `true` when none is set.
+ */
+export declare function getSanitizer(hot: HotInstance): boolean | SanitizerFn;
+/**
+ * Sanitizes an HTML string for surfaces that build markup as a string instead of writing it
+ * into an element through `fastInnerHTML` — the clipboard paste path and the nested-header
+ * ghost table.
+ *
+ * A configured sanitizer sees every payload, markup or not, which is what the clipboard path has
+ * always done. Only the missing-sanitizer warning is gated on markup. A caller that must match
+ * `fastInnerHTML` exactly, where plain text never reaches the sanitizer at all, has to apply that
+ * test itself before calling this. The nested-header ghost table does, so the label it measures is
+ * treated the same way as the header that renders it.
+ *
+ * The warning is bound to `hot.rootElement`, the scope every other surface uses, so all of them
+ * collapse into a single message per Handsontable instance.
+ *
+ * @param {object} hot The Handsontable instance.
+ * @param {string} html The HTML string to sanitize.
+ * @param {SanitizerContext} context The write surface, passed to the sanitizer and named in the warning.
+ * @returns {string} The sanitized string, or the input unchanged when no sanitizer is configured.
+ */
+export declare function sanitizeHTML(hot: HotInstance, html: string, context: SanitizerContext): string;

package/utils/sanitizer.js

@@ -0,0 +1,43 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get getSanitizer () {
+        return getSanitizer;
+    },
+    get sanitizeHTML () {
+        return sanitizeHTML;
+    }
+});
+const _element = require("../helpers/dom/element");
+const _console = require("../helpers/console");
+function getSanitizer(hot) {
+    return hot.getSettings().sanitizer ?? true;
+}
+function sanitizeHTML(hot, html, context) {
+    // An absent clipboard flavour reads as `''`. There is nothing to sanitize and nothing to warn
+    // about, and calling the sanitizer would add a spurious entry to an auditing one on every paste.
+    if (!html) {
+        return html;
+    }
+    const { sanitizer } = hot.getSettings();
+    // A configured sanitizer sees every payload, markup or not. Both callers behaved that way before
+    // this helper existed, and a sanitizer is not always an XSS filter - it may cap length, normalize
+    // whitespace, or record an audit entry, none of which it can do for input it never receives.
+    if (typeof sanitizer === 'function') {
+        return sanitizer(html, context) ?? '';
+    }
+    // The warning is the only part gated on markup: plain text cannot inject anything, so warning
+    // about it would be noise on every grid that writes an ordinary label.
+    if (_element.HTML_CHARACTERS.test(html)) {
+        (0, _console.warnOnce)(hot.rootElement, _element.SANITIZER_WARN_KEY, (0, _element.missingSanitizerMessage)(context));
+    }
+    return html;
+}