documonster 0.1.2 → 0.2.0

package/dist/browser/modules/excel/core/data-validations.d.ts

@@ -13,13 +13,19 @@ export interface DataValidationsData {
 }
 /** Create a data-validation registry, optionally seeded from a parsed model. */
 export declare function createDataValidations(model?: ValidationModel): DataValidationsData;
-/** Register a validation at an exact address. */
-export declare function dataValidationAdd(dv: DataValidationsData, address: string, validation: DataValidation): DataValidation;
+/**
+ * Register a validation for a cell or A1 range.
+ *
+ * Whole-column (`"A:A"`) and whole-row (`"1:3"`) references are expanded to
+ * Excel's sheet limits. Ranges are stored as a single `range:` model entry so
+ * they serialise to one data-validation element instead of one per cell.
+ */
+export declare function dataValidationAdd(dv: DataValidationsData, ref: string, validation: DataValidation): DataValidation;
 /**
  * Resolve the validation that applies to `address`: first an exact-address
  * match, then any `range:`-prefixed key whose decoded range contains it.
  */
 export declare function dataValidationFind(dv: DataValidationsData, address: string): DataValidation | undefined;
-/** Clear the validation registered at `address`. */
-export declare function dataValidationRemove(dv: DataValidationsData, address: string): void;
+/** Clear the validation registered for a cell or A1 range. */
+export declare function dataValidationRemove(dv: DataValidationsData, ref: string): void;
 export {};

package/dist/browser/modules/excel/core/data-validations.js

@@ -1,11 +1,101 @@
+import { InvalidAddressError } from "../errors.js";
 import { colCache } from "../utils/col-cache.js";
 /** Create a data-validation registry, optionally seeded from a parsed model. */
 export function createDataValidations(model) {
     return { model: model || {} };
 }
-/** Register a validation at an exact address. */
-export function dataValidationAdd(dv, address, validation) {
-    return (dv.model[address] = validation);
+/**
+ * Register a validation for a cell or A1 range.
+ *
+ * Whole-column (`"A:A"`) and whole-row (`"1:3"`) references are expanded to
+ * Excel's sheet limits. Ranges are stored as a single `range:` model entry so
+ * they serialise to one data-validation element instead of one per cell.
+ */
+export function dataValidationAdd(dv, ref, validation) {
+    return (dv.model[validationModelKey(ref)] = validation);
+}
+/** Excel's hard sheet limits, used to expand whole-column / whole-row refs. */
+const EXCEL_MAX_ROW = 1048576;
+const EXCEL_MAX_COL_LETTER = "XFD";
+/** Whole-column reference, e.g. "A:A" or "A:C" (optionally `$`-anchored). */
+const WHOLE_COLUMN_RE = /^\$?([A-Z]{1,3})\$?:\$?([A-Z]{1,3})$/;
+/** Whole-row reference, e.g. "1:1" or "2:5" (optionally `$`-anchored). */
+const WHOLE_ROW_RE = /^\$?(\d+)\$?:\$?(\d+)$/;
+/** A single concrete cell reference, e.g. "A1", "XFD1048576" (no `$`). */
+const CELL_RE = /^([A-Z]{1,3})(\d+)$/;
+/**
+ * Assert that `cell` is a valid, in-bounds A1 cell reference (`A1`..`XFD1048576`).
+ * `colCache.decodeEx` is too lenient (it happily returns garbage for "foo",
+ * "A0", etc.), so we validate strictly here to avoid persisting a malformed
+ * `sqref` that would corrupt the workbook.
+ */
+function assertValidCell(cell, ref) {
+    const m = cell.match(CELL_RE);
+    if (!m) {
+        throw new InvalidAddressError(ref, "not a valid cell or range reference");
+    }
+    colCache.l2n(m[1]); // throws ColumnOutOfBoundsError if the column is > XFD
+    const row = Number(m[2]);
+    if (row < 1 || row > EXCEL_MAX_ROW) {
+        throw new InvalidAddressError(ref, `row ${row} is outside 1..${EXCEL_MAX_ROW}`);
+    }
+}
+function decodeStrictCell(cell, ref) {
+    assertValidCell(cell, ref);
+    const m = cell.match(CELL_RE);
+    return { col: colCache.l2n(m[1]), row: Number(m[2]) };
+}
+function normaliseEndpoints(start, end, ref) {
+    const a = decodeStrictCell(start, ref);
+    const b = decodeStrictCell(end, ref);
+    const top = Math.min(a.row, b.row);
+    const left = Math.min(a.col, b.col);
+    const bottom = Math.max(a.row, b.row);
+    const right = Math.max(a.col, b.col);
+    return `${colCache.encodeAddress(top, left)}:${colCache.encodeAddress(bottom, right)}`;
+}
+/**
+ * Normalise a user-supplied A1 range reference into a concrete `top:bottom`
+ * range string suitable for a `range:` model key (and for the xlsx `sqref`).
+ *
+ * Handles the whole-column (`"A:A"`, `"A:C"`) and whole-row (`"1:3"`) shorthand
+ * by expanding them to Excel's sheet limits, mirroring how Excel itself stores
+ * a validation applied to an entire column (`A1:A1048576`). Any leading
+ * `Sheet!` qualifier is stripped, since data-validation `sqref` values are
+ * sheet-local. Absolute `$` markers are dropped. Throws
+ * {@link InvalidAddressError} for anything that is not a valid cell or range.
+ */
+function normaliseRangeRef(ref) {
+    if (typeof ref !== "string" || ref.length === 0) {
+        throw new InvalidAddressError(String(ref), "range reference must be a non-empty string");
+    }
+    // Strip a leading sheet qualifier: `Sheet1!A1:A10` / `'My Sheet'!A:A`.
+    const bang = ref.lastIndexOf("!");
+    const local = bang === -1 ? ref : ref.slice(bang + 1);
+    const wholeCol = local.match(WHOLE_COLUMN_RE);
+    if (wholeCol) {
+        return normaliseEndpoints(`${wholeCol[1]}1`, `${wholeCol[2]}${EXCEL_MAX_ROW}`, ref);
+    }
+    const wholeRow = local.match(WHOLE_ROW_RE);
+    if (wholeRow) {
+        return normaliseEndpoints(`A${wholeRow[1]}`, `${EXCEL_MAX_COL_LETTER}${wholeRow[2]}`, ref);
+    }
+    // Concrete cell or cell:cell range — drop absolute markers so keys match the
+    // `sqref` form Excel writes, then validate every endpoint strictly.
+    const bare = local.replace(/\$/g, "");
+    const endpoints = bare.split(":");
+    if (endpoints.length > 2) {
+        throw new InvalidAddressError(ref, "not a valid cell or range reference");
+    }
+    if (endpoints.length === 2) {
+        return normaliseEndpoints(endpoints[0], endpoints[1], ref);
+    }
+    assertValidCell(bare, ref);
+    return bare;
+}
+function validationModelKey(ref) {
+    const normalised = normaliseRangeRef(ref);
+    return normalised.includes(":") ? `range:${normalised}` : normalised;
 }
 /**
  * Resolve the validation that applies to `address`: first an exact-address
@@ -42,7 +132,7 @@ export function dataValidationFind(dv, address) {
     }
     return undefined;
 }
-/** Clear the validation registered at `address`. */
-export function dataValidationRemove(dv, address) {
-    dv.model[address] = undefined;
+/** Clear the validation registered for a cell or A1 range. */
+export function dataValidationRemove(dv, ref) {
+    dv.model[validationModelKey(ref)] = undefined;
 }

package/dist/cjs/modules/excel/core/data-validations.js

@@ -4,14 +4,104 @@ exports.createDataValidations = createDataValidations;
 exports.dataValidationAdd = dataValidationAdd;
 exports.dataValidationFind = dataValidationFind;
 exports.dataValidationRemove = dataValidationRemove;
+const errors_1 = require("../errors.js");
 const col_cache_1 = require("../utils/col-cache.js");
 /** Create a data-validation registry, optionally seeded from a parsed model. */
 function createDataValidations(model) {
     return { model: model || {} };
 }
-/** Register a validation at an exact address. */
-function dataValidationAdd(dv, address, validation) {
-    return (dv.model[address] = validation);
+/**
+ * Register a validation for a cell or A1 range.
+ *
+ * Whole-column (`"A:A"`) and whole-row (`"1:3"`) references are expanded to
+ * Excel's sheet limits. Ranges are stored as a single `range:` model entry so
+ * they serialise to one data-validation element instead of one per cell.
+ */
+function dataValidationAdd(dv, ref, validation) {
+    return (dv.model[validationModelKey(ref)] = validation);
+}
+/** Excel's hard sheet limits, used to expand whole-column / whole-row refs. */
+const EXCEL_MAX_ROW = 1048576;
+const EXCEL_MAX_COL_LETTER = "XFD";
+/** Whole-column reference, e.g. "A:A" or "A:C" (optionally `$`-anchored). */
+const WHOLE_COLUMN_RE = /^\$?([A-Z]{1,3})\$?:\$?([A-Z]{1,3})$/;
+/** Whole-row reference, e.g. "1:1" or "2:5" (optionally `$`-anchored). */
+const WHOLE_ROW_RE = /^\$?(\d+)\$?:\$?(\d+)$/;
+/** A single concrete cell reference, e.g. "A1", "XFD1048576" (no `$`). */
+const CELL_RE = /^([A-Z]{1,3})(\d+)$/;
+/**
+ * Assert that `cell` is a valid, in-bounds A1 cell reference (`A1`..`XFD1048576`).
+ * `colCache.decodeEx` is too lenient (it happily returns garbage for "foo",
+ * "A0", etc.), so we validate strictly here to avoid persisting a malformed
+ * `sqref` that would corrupt the workbook.
+ */
+function assertValidCell(cell, ref) {
+    const m = cell.match(CELL_RE);
+    if (!m) {
+        throw new errors_1.InvalidAddressError(ref, "not a valid cell or range reference");
+    }
+    col_cache_1.colCache.l2n(m[1]); // throws ColumnOutOfBoundsError if the column is > XFD
+    const row = Number(m[2]);
+    if (row < 1 || row > EXCEL_MAX_ROW) {
+        throw new errors_1.InvalidAddressError(ref, `row ${row} is outside 1..${EXCEL_MAX_ROW}`);
+    }
+}
+function decodeStrictCell(cell, ref) {
+    assertValidCell(cell, ref);
+    const m = cell.match(CELL_RE);
+    return { col: col_cache_1.colCache.l2n(m[1]), row: Number(m[2]) };
+}
+function normaliseEndpoints(start, end, ref) {
+    const a = decodeStrictCell(start, ref);
+    const b = decodeStrictCell(end, ref);
+    const top = Math.min(a.row, b.row);
+    const left = Math.min(a.col, b.col);
+    const bottom = Math.max(a.row, b.row);
+    const right = Math.max(a.col, b.col);
+    return `${col_cache_1.colCache.encodeAddress(top, left)}:${col_cache_1.colCache.encodeAddress(bottom, right)}`;
+}
+/**
+ * Normalise a user-supplied A1 range reference into a concrete `top:bottom`
+ * range string suitable for a `range:` model key (and for the xlsx `sqref`).
+ *
+ * Handles the whole-column (`"A:A"`, `"A:C"`) and whole-row (`"1:3"`) shorthand
+ * by expanding them to Excel's sheet limits, mirroring how Excel itself stores
+ * a validation applied to an entire column (`A1:A1048576`). Any leading
+ * `Sheet!` qualifier is stripped, since data-validation `sqref` values are
+ * sheet-local. Absolute `$` markers are dropped. Throws
+ * {@link InvalidAddressError} for anything that is not a valid cell or range.
+ */
+function normaliseRangeRef(ref) {
+    if (typeof ref !== "string" || ref.length === 0) {
+        throw new errors_1.InvalidAddressError(String(ref), "range reference must be a non-empty string");
+    }
+    // Strip a leading sheet qualifier: `Sheet1!A1:A10` / `'My Sheet'!A:A`.
+    const bang = ref.lastIndexOf("!");
+    const local = bang === -1 ? ref : ref.slice(bang + 1);
+    const wholeCol = local.match(WHOLE_COLUMN_RE);
+    if (wholeCol) {
+        return normaliseEndpoints(`${wholeCol[1]}1`, `${wholeCol[2]}${EXCEL_MAX_ROW}`, ref);
+    }
+    const wholeRow = local.match(WHOLE_ROW_RE);
+    if (wholeRow) {
+        return normaliseEndpoints(`A${wholeRow[1]}`, `${EXCEL_MAX_COL_LETTER}${wholeRow[2]}`, ref);
+    }
+    // Concrete cell or cell:cell range — drop absolute markers so keys match the
+    // `sqref` form Excel writes, then validate every endpoint strictly.
+    const bare = local.replace(/\$/g, "");
+    const endpoints = bare.split(":");
+    if (endpoints.length > 2) {
+        throw new errors_1.InvalidAddressError(ref, "not a valid cell or range reference");
+    }
+    if (endpoints.length === 2) {
+        return normaliseEndpoints(endpoints[0], endpoints[1], ref);
+    }
+    assertValidCell(bare, ref);
+    return bare;
+}
+function validationModelKey(ref) {
+    const normalised = normaliseRangeRef(ref);
+    return normalised.includes(":") ? `range:${normalised}` : normalised;
 }
 /**
  * Resolve the validation that applies to `address`: first an exact-address
@@ -48,7 +138,7 @@ function dataValidationFind(dv, address) {
     }
     return undefined;
 }
-/** Clear the validation registered at `address`. */
-function dataValidationRemove(dv, address) {
-    dv.model[address] = undefined;
+/** Clear the validation registered for a cell or A1 range. */
+function dataValidationRemove(dv, ref) {
+    dv.model[validationModelKey(ref)] = undefined;
 }

package/dist/esm/modules/excel/core/data-validations.js

@@ -1,11 +1,101 @@
+import { InvalidAddressError } from "../errors.js";
 import { colCache } from "../utils/col-cache.js";
 /** Create a data-validation registry, optionally seeded from a parsed model. */
 export function createDataValidations(model) {
     return { model: model || {} };
 }
-/** Register a validation at an exact address. */
-export function dataValidationAdd(dv, address, validation) {
-    return (dv.model[address] = validation);
+/**
+ * Register a validation for a cell or A1 range.
+ *
+ * Whole-column (`"A:A"`) and whole-row (`"1:3"`) references are expanded to
+ * Excel's sheet limits. Ranges are stored as a single `range:` model entry so
+ * they serialise to one data-validation element instead of one per cell.
+ */
+export function dataValidationAdd(dv, ref, validation) {
+    return (dv.model[validationModelKey(ref)] = validation);
+}
+/** Excel's hard sheet limits, used to expand whole-column / whole-row refs. */
+const EXCEL_MAX_ROW = 1048576;
+const EXCEL_MAX_COL_LETTER = "XFD";
+/** Whole-column reference, e.g. "A:A" or "A:C" (optionally `$`-anchored). */
+const WHOLE_COLUMN_RE = /^\$?([A-Z]{1,3})\$?:\$?([A-Z]{1,3})$/;
+/** Whole-row reference, e.g. "1:1" or "2:5" (optionally `$`-anchored). */
+const WHOLE_ROW_RE = /^\$?(\d+)\$?:\$?(\d+)$/;
+/** A single concrete cell reference, e.g. "A1", "XFD1048576" (no `$`). */
+const CELL_RE = /^([A-Z]{1,3})(\d+)$/;
+/**
+ * Assert that `cell` is a valid, in-bounds A1 cell reference (`A1`..`XFD1048576`).
+ * `colCache.decodeEx` is too lenient (it happily returns garbage for "foo",
+ * "A0", etc.), so we validate strictly here to avoid persisting a malformed
+ * `sqref` that would corrupt the workbook.
+ */
+function assertValidCell(cell, ref) {
+    const m = cell.match(CELL_RE);
+    if (!m) {
+        throw new InvalidAddressError(ref, "not a valid cell or range reference");
+    }
+    colCache.l2n(m[1]); // throws ColumnOutOfBoundsError if the column is > XFD
+    const row = Number(m[2]);
+    if (row < 1 || row > EXCEL_MAX_ROW) {
+        throw new InvalidAddressError(ref, `row ${row} is outside 1..${EXCEL_MAX_ROW}`);
+    }
+}
+function decodeStrictCell(cell, ref) {
+    assertValidCell(cell, ref);
+    const m = cell.match(CELL_RE);
+    return { col: colCache.l2n(m[1]), row: Number(m[2]) };
+}
+function normaliseEndpoints(start, end, ref) {
+    const a = decodeStrictCell(start, ref);
+    const b = decodeStrictCell(end, ref);
+    const top = Math.min(a.row, b.row);
+    const left = Math.min(a.col, b.col);
+    const bottom = Math.max(a.row, b.row);
+    const right = Math.max(a.col, b.col);
+    return `${colCache.encodeAddress(top, left)}:${colCache.encodeAddress(bottom, right)}`;
+}
+/**
+ * Normalise a user-supplied A1 range reference into a concrete `top:bottom`
+ * range string suitable for a `range:` model key (and for the xlsx `sqref`).
+ *
+ * Handles the whole-column (`"A:A"`, `"A:C"`) and whole-row (`"1:3"`) shorthand
+ * by expanding them to Excel's sheet limits, mirroring how Excel itself stores
+ * a validation applied to an entire column (`A1:A1048576`). Any leading
+ * `Sheet!` qualifier is stripped, since data-validation `sqref` values are
+ * sheet-local. Absolute `$` markers are dropped. Throws
+ * {@link InvalidAddressError} for anything that is not a valid cell or range.
+ */
+function normaliseRangeRef(ref) {
+    if (typeof ref !== "string" || ref.length === 0) {
+        throw new InvalidAddressError(String(ref), "range reference must be a non-empty string");
+    }
+    // Strip a leading sheet qualifier: `Sheet1!A1:A10` / `'My Sheet'!A:A`.
+    const bang = ref.lastIndexOf("!");
+    const local = bang === -1 ? ref : ref.slice(bang + 1);
+    const wholeCol = local.match(WHOLE_COLUMN_RE);
+    if (wholeCol) {
+        return normaliseEndpoints(`${wholeCol[1]}1`, `${wholeCol[2]}${EXCEL_MAX_ROW}`, ref);
+    }
+    const wholeRow = local.match(WHOLE_ROW_RE);
+    if (wholeRow) {
+        return normaliseEndpoints(`A${wholeRow[1]}`, `${EXCEL_MAX_COL_LETTER}${wholeRow[2]}`, ref);
+    }
+    // Concrete cell or cell:cell range — drop absolute markers so keys match the
+    // `sqref` form Excel writes, then validate every endpoint strictly.
+    const bare = local.replace(/\$/g, "");
+    const endpoints = bare.split(":");
+    if (endpoints.length > 2) {
+        throw new InvalidAddressError(ref, "not a valid cell or range reference");
+    }
+    if (endpoints.length === 2) {
+        return normaliseEndpoints(endpoints[0], endpoints[1], ref);
+    }
+    assertValidCell(bare, ref);
+    return bare;
+}
+function validationModelKey(ref) {
+    const normalised = normaliseRangeRef(ref);
+    return normalised.includes(":") ? `range:${normalised}` : normalised;
 }
 /**
  * Resolve the validation that applies to `address`: first an exact-address
@@ -42,7 +132,7 @@ export function dataValidationFind(dv, address) {
     }
     return undefined;
 }
-/** Clear the validation registered at `address`. */
-export function dataValidationRemove(dv, address) {
-    dv.model[address] = undefined;
+/** Clear the validation registered for a cell or A1 range. */
+export function dataValidationRemove(dv, ref) {
+    dv.model[validationModelKey(ref)] = undefined;
 }

package/dist/iife/documonster.archive.iife.js

@@ -1,5 +1,5 @@
 /*!
-* documonster v0.1.2
+* documonster v0.2.0
 * Zero-dependency TypeScript toolkit for Excel, Word, PDF, CSV, Markdown, XML & ZIP — one API across Node.js, Bun & browsers.
 * (c) 2026 cjnoname
 * Released under the Apache-2.0 License

package/dist/iife/documonster.archive.iife.min.js

@@ -1,5 +1,5 @@
 /*!
-* documonster v0.1.2
+* documonster v0.2.0
 * Zero-dependency TypeScript toolkit for Excel, Word, PDF, CSV, Markdown, XML & ZIP — one API across Node.js, Bun & browsers.
 * (c) 2026 cjnoname
 * Released under the Apache-2.0 License

package/dist/iife/documonster.csv.iife.js

@@ -1,5 +1,5 @@
 /*!
-* documonster v0.1.2
+* documonster v0.2.0
 * Zero-dependency TypeScript toolkit for Excel, Word, PDF, CSV, Markdown, XML & ZIP — one API across Node.js, Bun & browsers.
 * (c) 2026 cjnoname
 * Released under the Apache-2.0 License

package/dist/iife/documonster.csv.iife.min.js

@@ -1,5 +1,5 @@
 /*!
-* documonster v0.1.2
+* documonster v0.2.0
 * Zero-dependency TypeScript toolkit for Excel, Word, PDF, CSV, Markdown, XML & ZIP — one API across Node.js, Bun & browsers.
 * (c) 2026 cjnoname
 * Released under the Apache-2.0 License

package/dist/iife/documonster.excel.iife.js

@@ -1,5 +1,5 @@
 /*!
-* documonster v0.1.2
+* documonster v0.2.0
 * Zero-dependency TypeScript toolkit for Excel, Word, PDF, CSV, Markdown, XML & ZIP — one API across Node.js, Bun & browsers.
 * (c) 2026 cjnoname
 * Released under the Apache-2.0 License
@@ -501,14 +501,90 @@ this.Documonster = this.Documonster || {};
 	}));
 	//#endregion
 	//#region src/modules/excel/core/data-validations.ts
+	init_errors$2();
 	init_col_cache();
 	/** Create a data-validation registry, optionally seeded from a parsed model. */
 	function createDataValidations(model) {
 		return { model: model || {} };
 	}
-	/** Register a validation at an exact address. */
-	function dataValidationAdd(dv, address, validation) {
-		return dv.model[address] = validation;
+	/**
+	* Register a validation for a cell or A1 range.
+	*
+	* Whole-column (`"A:A"`) and whole-row (`"1:3"`) references are expanded to
+	* Excel's sheet limits. Ranges are stored as a single `range:` model entry so
+	* they serialise to one data-validation element instead of one per cell.
+	*/
+	function dataValidationAdd(dv, ref, validation) {
+		return dv.model[validationModelKey(ref)] = validation;
+	}
+	/** Excel's hard sheet limits, used to expand whole-column / whole-row refs. */
+	const EXCEL_MAX_ROW$2 = 1048576;
+	const EXCEL_MAX_COL_LETTER = "XFD";
+	/** Whole-column reference, e.g. "A:A" or "A:C" (optionally `$`-anchored). */
+	const WHOLE_COLUMN_RE = /^\$?([A-Z]{1,3})\$?:\$?([A-Z]{1,3})$/;
+	/** Whole-row reference, e.g. "1:1" or "2:5" (optionally `$`-anchored). */
+	const WHOLE_ROW_RE = /^\$?(\d+)\$?:\$?(\d+)$/;
+	/** A single concrete cell reference, e.g. "A1", "XFD1048576" (no `$`). */
+	const CELL_RE = /^([A-Z]{1,3})(\d+)$/;
+	/**
+	* Assert that `cell` is a valid, in-bounds A1 cell reference (`A1`..`XFD1048576`).
+	* `colCache.decodeEx` is too lenient (it happily returns garbage for "foo",
+	* "A0", etc.), so we validate strictly here to avoid persisting a malformed
+	* `sqref` that would corrupt the workbook.
+	*/
+	function assertValidCell(cell, ref) {
+		const m = cell.match(CELL_RE);
+		if (!m) throw new InvalidAddressError(ref, "not a valid cell or range reference");
+		colCache.l2n(m[1]);
+		const row = Number(m[2]);
+		if (row < 1 || row > EXCEL_MAX_ROW$2) throw new InvalidAddressError(ref, `row ${row} is outside 1..${EXCEL_MAX_ROW$2}`);
+	}
+	function decodeStrictCell(cell, ref) {
+		assertValidCell(cell, ref);
+		const m = cell.match(CELL_RE);
+		return {
+			col: colCache.l2n(m[1]),
+			row: Number(m[2])
+		};
+	}
+	function normaliseEndpoints(start, end, ref) {
+		const a = decodeStrictCell(start, ref);
+		const b = decodeStrictCell(end, ref);
+		const top = Math.min(a.row, b.row);
+		const left = Math.min(a.col, b.col);
+		const bottom = Math.max(a.row, b.row);
+		const right = Math.max(a.col, b.col);
+		return `${colCache.encodeAddress(top, left)}:${colCache.encodeAddress(bottom, right)}`;
+	}
+	/**
+	* Normalise a user-supplied A1 range reference into a concrete `top:bottom`
+	* range string suitable for a `range:` model key (and for the xlsx `sqref`).
+	*
+	* Handles the whole-column (`"A:A"`, `"A:C"`) and whole-row (`"1:3"`) shorthand
+	* by expanding them to Excel's sheet limits, mirroring how Excel itself stores
+	* a validation applied to an entire column (`A1:A1048576`). Any leading
+	* `Sheet!` qualifier is stripped, since data-validation `sqref` values are
+	* sheet-local. Absolute `$` markers are dropped. Throws
+	* {@link InvalidAddressError} for anything that is not a valid cell or range.
+	*/
+	function normaliseRangeRef(ref) {
+		if (typeof ref !== "string" || ref.length === 0) throw new InvalidAddressError(String(ref), "range reference must be a non-empty string");
+		const bang = ref.lastIndexOf("!");
+		const local = bang === -1 ? ref : ref.slice(bang + 1);
+		const wholeCol = local.match(WHOLE_COLUMN_RE);
+		if (wholeCol) return normaliseEndpoints(`${wholeCol[1]}1`, `${wholeCol[2]}${EXCEL_MAX_ROW$2}`, ref);
+		const wholeRow = local.match(WHOLE_ROW_RE);
+		if (wholeRow) return normaliseEndpoints(`A${wholeRow[1]}`, `${EXCEL_MAX_COL_LETTER}${wholeRow[2]}`, ref);
+		const bare = local.replace(/\$/g, "");
+		const endpoints = bare.split(":");
+		if (endpoints.length > 2) throw new InvalidAddressError(ref, "not a valid cell or range reference");
+		if (endpoints.length === 2) return normaliseEndpoints(endpoints[0], endpoints[1], ref);
+		assertValidCell(bare, ref);
+		return bare;
+	}
+	function validationModelKey(ref) {
+		const normalised = normaliseRangeRef(ref);
+		return normalised.includes(":") ? `range:${normalised}` : normalised;
 	}
 	/**
 	* Resolve the validation that applies to `address`: first an exact-address
@@ -530,9 +606,9 @@ this.Documonster = this.Documonster || {};
 			if (decoded.row >= tlAddr.row && decoded.row <= brAddr.row && decoded.col >= tlAddr.col && decoded.col <= brAddr.col) return dv.model[key];
 		}
 	}
-	/** Clear the validation registered at `address`. */
-	function dataValidationRemove(dv, address) {
-		dv.model[address] = void 0;
+	/** Clear the validation registered for a cell or A1 range. */
+	function dataValidationRemove(dv, ref) {
+		dv.model[validationModelKey(ref)] = void 0;
 	}
 	//#endregion
 	//#region src/modules/excel/core/range.ts
@@ -45606,7 +45682,6 @@ self.onmessage = async function(event) {
 	var WRITE_AFTER_END_ERROR, AsyncStreamCodec, BufferedCodec;
 	var init_streaming_compress_browser = __esmMin((() => {
 		init_compress_base();
-		init_compress_browser();
 		init_deflate_fallback();
 		init_index_browser();
 		init_defaults();