@opengeni/artifact-tool 0.2.2

package/LICENSE

@@ -0,0 +1,190 @@
+                                 Apache License
+                           Version 2.0, January 2004
+                        http://www.apache.org/licenses/
+
+   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
+
+   1. Definitions.
+
+      "License" shall mean the terms and conditions for use, reproduction,
+      and distribution as defined by Sections 1 through 9 of this document.
+
+      "Licensor" shall mean the copyright owner or entity authorized by
+      the copyright owner that is granting the License.
+
+      "Legal Entity" shall mean the union of the acting entity and all
+      other entities that control, are controlled by, or are under common
+      control with that entity. For the purposes of this definition,
+      "control" means (i) the power, direct or indirect, to cause the
+      direction or management of such entity, whether by contract or
+      otherwise, or (ii) ownership of fifty percent (50%) or more of the
+      outstanding shares, or (iii) beneficial ownership of such entity.
+
+      "You" (or "Your") shall mean an individual or Legal Entity
+      exercising permissions granted by this License.
+
+      "Source" form shall mean the preferred form for making modifications,
+      including but not limited to software source code, documentation
+      source, and configuration files.
+
+      "Object" form shall mean any form resulting from mechanical
+      transformation or translation of a Source form, including but
+      not limited to compiled object code, generated documentation,
+      and conversions to other media types.
+
+      "Work" shall mean the work of authorship, whether in Source or
+      Object form, made available under the License, as indicated by a
+      copyright notice that is included in or attached to the work
+      (an example is provided in the Appendix below).
+
+      "Derivative Works" shall mean any work, whether in Source or Object
+      form, that is based on (or derived from) the Work and for which the
+      editorial revisions, annotations, elaborations, or other modifications
+      represent, as a whole, an original work of authorship. For the purposes
+      of this License, Derivative Works shall not include works that remain
+      separable from, or merely link (or bind by name) to the interfaces of,
+      the Work and Derivative Works thereof.
+
+      "Contribution" shall mean any work of authorship, including
+      the original version of the Work and any modifications or additions
+      to that Work or Derivative Works thereof, that is intentionally
+      submitted to Licensor for inclusion in the Work by the copyright owner
+      or by an individual or Legal Entity authorized to submit on behalf of
+      the copyright owner. For the purposes of this definition, "submitted"
+      means any form of electronic, verbal, or written communication sent
+      to the Licensor or its representatives, including but not limited to
+      communication on electronic mailing lists, source code control systems,
+      and issue tracking systems that are managed by, or on behalf of, the
+      Licensor for the purpose of discussing and improving the Work, but
+      excluding communication that is conspicuously marked or otherwise
+      designated in writing by the copyright owner as "Not a Contribution."
+
+      "Contributor" shall mean Licensor and any individual or Legal Entity
+      on behalf of whom a Contribution has been received by Licensor and
+      subsequently incorporated within the Work.
+
+   2. Grant of Copyright License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      copyright license to reproduce, prepare Derivative Works of,
+      publicly display, publicly perform, sublicense, and distribute the
+      Work and such Derivative Works in Source or Object form.
+
+   3. Grant of Patent License. Subject to the terms and conditions of
+      this License, each Contributor hereby grants to You a perpetual,
+      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
+      (except as stated in this section) patent license to make, have made,
+      use, offer to sell, sell, import, and otherwise transfer the Work,
+      where such license applies only to those patent claims licensable
+      by such Contributor that are necessarily infringed by their
+      Contribution(s) alone or by combination of their Contribution(s)
+      with the Work to which such Contribution(s) was submitted. If You
+      institute patent litigation against any entity (including a
+      cross-claim or counterclaim in a lawsuit) alleging that the Work
+      or a Contribution incorporated within the Work constitutes direct
+      or contributory patent infringement, then any patent licenses
+      granted to You under this License for that Work shall terminate
+      as of the date such litigation is filed.
+
+   4. Redistribution. You may reproduce and distribute copies of the
+      Work or Derivative Works thereof in any medium, with or without
+      modifications, and in Source or Object form, provided that You
+      meet the following conditions:
+
+      (a) You must give any other recipients of the Work or
+          Derivative Works a copy of this License; and
+
+      (b) You must cause any modified files to carry prominent notices
+          stating that You changed the files; and
+
+      (c) You must retain, in the Source form of any Derivative Works
+          that You distribute, all copyright, patent, trademark, and
+          attribution notices from the Source form of the Work,
+          excluding those notices that do not pertain to any part of
+          the Derivative Works; and
+
+      (d) If the Work includes a "NOTICE" text file as part of its
+          distribution, then any Derivative Works that You distribute must
+          include a readable copy of the attribution notices contained
+          within such NOTICE file, excluding those notices that do not
+          pertain to any part of the Derivative Works, in at least one
+          of the following places: within a NOTICE text file distributed
+          as part of the Derivative Works; within the Source form or
+          documentation, if provided along with the Derivative Works; or,
+          within a display generated by the Derivative Works, if and
+          wherever such third-party notices normally appear. The contents
+          of the NOTICE file are for informational purposes only and
+          do not modify the License. You may add Your own attribution
+          notices within Derivative Works that You distribute, alongside
+          or as an addendum to the NOTICE text from the Work, provided
+          that such additional attribution notices cannot be construed
+          as modifying the License.
+
+      You may add Your own copyright statement to Your modifications and
+      may provide additional or different license terms and conditions
+      for use, reproduction, or distribution of Your modifications, or
+      for any such Derivative Works as a whole, provided Your use,
+      reproduction, and distribution of the Work otherwise complies with
+      the conditions stated in this License.
+
+   5. Submission of Contributions. Unless You explicitly state otherwise,
+      any Contribution intentionally submitted for inclusion in the Work
+      by You to the Licensor shall be under the terms and conditions of
+      this License, without any additional terms or conditions.
+      Notwithstanding the above, nothing herein shall supersede or modify
+      the terms of any separate license agreement you may have executed
+      with Licensor regarding such Contributions.
+
+   6. Trademarks. This License does not grant permission to use the trade
+      names, trademarks, service marks, or product names of the Licensor,
+      except as required for reasonable and customary use in describing the
+      origin of the Work and reproducing the content of the NOTICE file.
+
+   7. Disclaimer of Warranty. Unless required by applicable law or
+      agreed to in writing, Licensor provides the Work (and each
+      Contributor provides its Contributions) on an "AS IS" BASIS,
+      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
+      implied, including, without limitation, any warranties or conditions
+      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
+      PARTICULAR PURPOSE. You are solely responsible for determining the
+      appropriateness of using or redistributing the Work and assume any
+      risks associated with Your exercise of permissions under this License.
+
+   8. Limitation of Liability. In no event and under no legal theory,
+      whether in tort (including negligence), contract, or otherwise,
+      unless required by applicable law (such as deliberate and grossly
+      negligent acts) or agreed to in writing, shall any Contributor be
+      liable to You for damages, including any direct, indirect, special,
+      incidental, or consequential damages of any character arising as a
+      result of this License or out of the use or inability to use the
+      Work (including but not limited to damages for loss of goodwill,
+      work stoppage, computer failure or malfunction, or any and all
+      other commercial damages or losses), even if such Contributor
+      has been advised of the possibility of such damages.
+
+   9. Accepting Warranty or Additional Liability. While redistributing
+      the Work or Derivative Works thereof, You may choose to offer,
+      and charge a fee for, acceptance of support, warranty, indemnity,
+      or other liability obligations and/or rights consistent with this
+      License. However, in accepting such obligations, You may act only
+      on Your own behalf and on Your sole responsibility, not on behalf
+      of any other Contributor, and only if You agree to indemnify,
+      defend, and hold each Contributor harmless for any liability
+      incurred by, or claims asserted against, such Contributor by reason
+      of your accepting any such warranty or additional liability.
+
+   END OF TERMS AND CONDITIONS
+
+   Copyright 2026 Cloudgeni-ai
+
+   Licensed under the Apache License, Version 2.0 (the "License");
+   you may not use this file except in compliance with the License.
+   You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+   Unless required by applicable law or agreed to in writing, software
+   distributed under the License is distributed on an "AS IS" BASIS,
+   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+   See the License for the specific language governing permissions and
+   limitations under the License.

package/README.md

@@ -0,0 +1,104 @@
+# `@opengeni/artifact-tool`
+
+OpenGeni's Office-artifact engine. The package root is the synchronous exact
+native skill facade; hosts must configure its manifest-pinned N-API runtime
+before creating an artifact. `@opengeni/artifact-tool/reference` is the
+explicit universal TypeScript fixture/codec model, while browser production
+editing is owned by the SDK Worker and paired WASM kernel.
+
+The public authoring API intentionally follows the artifact workflows shipped
+with OpenGeni's spreadsheet and presentation skills:
+
+```ts
+import { SpreadsheetFile, Workbook } from "@opengeni/artifact-tool";
+
+const workbook = Workbook.create();
+const sheet = workbook.worksheets.add("Summary");
+sheet.getRange("A1:B3").values = [
+  ["Month", "Revenue"],
+  ["Jan", 100],
+  ["Feb", 120],
+];
+const output = await SpreadsheetFile.exportXlsx(workbook);
+await output.save("summary.xlsx");
+```
+
+Design invariants:
+
+- Sparse live models; rectangular writes are one transaction.
+- Stable object ids and deterministic inspection output.
+- Formula values derive from formulas; exports never replace formulas with
+  hardcoded display values.
+- Render and Office-file codecs are replaceable adapters around the same model.
+- Unknown imported content is never silently presented as supported.
+
+Every root-facade mutation is atomic across the host projection and native
+session. Use `artifact.batch(draft => { ... })` for many sequential public
+mutations: it applies host calls synchronously, reconciles native state once,
+and rolls the complete batch back on failure. On the measured Darwin-arm64
+fixture, 1,000 calls took 9.65 s spreadsheet / 4.48 s document / 7.20 s
+presentation unbatched versus under 70 ms per modality batched. Ordinary
+single calls remain exact; large builders must batch rather than rely on the
+full-projection reconciliation fallback.
+
+Filesystem, rasterization, and Office codecs remain lazy and outside the eager
+facade closure.
+
+## Kernel distribution status
+
+The safe-Rust N-API and WebAssembly bindings are implemented and verified in
+`kernel/bindings`. This package intentionally does **not** embed a partial
+binary matrix: its tarball contains `dist/` and `src/`, while exact generated
+kernel target packages carry platform assets separately.
+The exported runtime locator/doctor verifies a local canonical installation
+manifest, complete release manifest, pinned facade, target package, and every
+executable byte before evaluating code. It performs no download, `latest`
+lookup, target guess, or TypeScript fallback.
+
+Native publication is one atomic matrix: macOS arm64/x64, Linux glibc
+arm64/x64, Linux musl arm64/x64, and Windows x64, plus one browser-WASM
+glue/binary/type set built from the same Rust source and protocol identity.
+Every target requires a canonical receipt produced by executing its smoke test;
+until every declared asset is present and provenance-verified, a complete
+release cannot be materialized and production loading fails closed.
+
+Installed hosts expose the exact local assembly with
+`OPENGENI_ARTIFACT_RUNTIME_MANIFEST` and `OPENGENI_ARTIFACT_TOOL_ENTRY`. They
+can run `opengeni-artifact-runtime locate --json` for verification without code
+evaluation, or `opengeni-artifact-runtime doctor --json` to verify, load the
+pinned bootstrap, and perform a minimal native facade health probe. Both
+commands fail closed and return machine-readable JSON; neither performs network
+discovery.
+
+`scripts/assemble-artifact-runtime-installation.ts` is the production
+installer. It accepts only absolute local paths to one canonical complete
+release manifest, its exact already-materialized target package, and the packed
+artifact-tool tarball named by that manifest. It verifies package identity,
+tarball SHA-512, smoke receipt, and every runtime-file SHA-256 before atomically
+publishing a relocatable root with a relative kernel import. The two OCI inputs
+are assembled atomically by
+`scripts/assemble-artifact-runtime-container-inputs.ts`: `amd64` is exactly
+`linux-x64-gnu`; `arm64` is exactly `linux-arm64-gnu`. Missing either target
+preserves the previous complete tree and fails the build.
+
+`.github/workflows/artifact-runtime.yml` produces the inputs. Seven OS-native
+jobs execute the addon on its exact target host/userspace; one WASM job executes
+the generated browser ABI. Aggregation requires all eight canonical receipts,
+one build identity, and the exact packed artifact-tool integrity, then runs the
+strict doctor directly and through both Docker architectures. CI and immutable
+release-candidate image builds consume only that run-local verified artifact.
+
+Local development is deliberately separate. `scripts/dev-stack.sh` installs
+workspace links first, then `scripts/prepare-development-artifact-runtime.ts`
+builds and smokes only the current native host when its canonical source +
+Rust-toolchain fingerprint is absent or stale. It writes the ignored
+`.opengeni/artifact-runtime-development` bundle and exports its exact paths in
+`.env.runtime`. This development manifest is a different schema, cannot claim
+missing targets, cannot coexist with the production manifest, and is rejected
+when `NODE_ENV=production`.
+
+Performance evidence is deliberately narrower than the target matrix. The
+machine-readable status in `bench/platform-evidence.json` distinguishes local
+Darwin-arm64/kernel-WASM measurements from still-unmeasured packaged,
+cross-platform, and sandbox runtimes; one platform's kernel result is never
+presented as evidence for another.

package/dist/bounded-zip.d.ts

@@ -0,0 +1,28 @@
+export type BoundedZipEntry = {
+    name: string;
+    flags: number;
+    compression: 0 | 8;
+    checksum: number;
+    compressedSize: number;
+    expandedSize: number;
+    localHeaderOffset: number;
+    dataStart: number;
+    dataEnd: number;
+    recordEnd: number;
+    directory: boolean;
+};
+export type BoundedZipLimits = {
+    entries: number;
+    compressedEntryBytes: number;
+    expandedEntryBytes: number;
+    expandedBytes: number;
+    compressionRatio: number;
+    compressionRatioThreshold?: number;
+};
+export type BoundedZipFailure = (kind: "invalid" | "unsupported" | "encrypted" | "limit" | "platform", message: string, entryName?: string) => never;
+/** Parses ZIP metadata and validates every local record without inflating payloads. */
+export declare function parseBoundedZip(bytes: Uint8Array, limits: BoundedZipLimits, fail: BoundedZipFailure): BoundedZipEntry[];
+export declare function inflateBoundedZipEntry(archive: Uint8Array, entry: BoundedZipEntry, maximumBytes: number, fail: BoundedZipFailure): Promise<Uint8Array>;
+export declare function verifyBoundedZipEntry(archive: Uint8Array, entry: BoundedZipEntry, maximumBytes: number, fail: BoundedZipFailure): Promise<void>;
+export declare function zipCrc32Update(initial: number, bytes: Uint8Array): number;
+export declare function zipCrc32(bytes: Uint8Array): number;

package/dist/chunk-4BSENMAE.js

@@ -0,0 +1,39 @@
+// src/file-blob.ts
+var FileBlob = class _FileBlob extends Blob {
+  name;
+  constructor(parts, options = {}) {
+    super(parts, options);
+    this.name = options.name ?? null;
+  }
+  static async load(path) {
+    const fs = await loadNodeFileSystem();
+    const bytes = await fs.readFile(path);
+    return new _FileBlob([bytes], { name: path });
+  }
+  static fromBytes(bytes, options = {}) {
+    return new _FileBlob([bytes instanceof Uint8Array ? ownedBytes(bytes) : bytes], options);
+  }
+  async save(path) {
+    const fs = await loadNodeFileSystem();
+    await fs.writeFile(path, new Uint8Array(await this.arrayBuffer()));
+  }
+};
+async function loadNodeFileSystem() {
+  return importRuntimeModule("node:fs/promises");
+}
+function importRuntimeModule(specifier) {
+  return import(
+    /* @vite-ignore */
+    specifier
+  );
+}
+function ownedBytes(bytes) {
+  const copy = new Uint8Array(bytes.byteLength);
+  copy.set(bytes);
+  return copy;
+}
+
+export {
+  FileBlob
+};
+//# sourceMappingURL=chunk-4BSENMAE.js.map

package/dist/chunk-4BSENMAE.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../src/file-blob.ts"],"sourcesContent":["export class FileBlob extends Blob {\n  readonly name: string | null;\n\n  constructor(parts: BlobPart[], options: BlobPropertyBag & { name?: string | null } = {}) {\n    super(parts, options);\n    this.name = options.name ?? null;\n  }\n\n  static async load(path: string): Promise<FileBlob> {\n    const fs = await loadNodeFileSystem();\n    const bytes = await fs.readFile(path);\n    return new FileBlob([bytes], { name: path });\n  }\n\n  static fromBytes(\n    bytes: Uint8Array | ArrayBuffer,\n    options: BlobPropertyBag & { name?: string | null } = {},\n  ): FileBlob {\n    return new FileBlob([bytes instanceof Uint8Array ? ownedBytes(bytes) : bytes], options);\n  }\n\n  async save(path: string): Promise<void> {\n    const fs = await loadNodeFileSystem();\n    await fs.writeFile(path, new Uint8Array(await this.arrayBuffer()));\n  }\n}\n\nasync function loadNodeFileSystem(): Promise<typeof import(\"node:fs/promises\")> {\n  // A literal dynamic import is still eagerly resolved by browser bundlers.\n  // Keep this Node-only capability out of browser artifacts while retaining\n  // ordinary native ESM resolution when load/save is actually called in Node.\n  return importRuntimeModule<typeof import(\"node:fs/promises\")>(\"node:fs/promises\");\n}\n\nfunction importRuntimeModule<T>(specifier: string): Promise<T> {\n  return import(/* @vite-ignore */ specifier) as Promise<T>;\n}\n\nfunction ownedBytes(bytes: Uint8Array): Uint8Array<ArrayBuffer> {\n  const copy = new Uint8Array(bytes.byteLength);\n  copy.set(bytes);\n  return copy;\n}\n"],"mappings":";AAAO,IAAM,WAAN,MAAM,kBAAiB,KAAK;AAAA,EACxB;AAAA,EAET,YAAY,OAAmB,UAAsD,CAAC,GAAG;AACvF,UAAM,OAAO,OAAO;AACpB,SAAK,OAAO,QAAQ,QAAQ;AAAA,EAC9B;AAAA,EAEA,aAAa,KAAK,MAAiC;AACjD,UAAM,KAAK,MAAM,mBAAmB;AACpC,UAAM,QAAQ,MAAM,GAAG,SAAS,IAAI;AACpC,WAAO,IAAI,UAAS,CAAC,KAAK,GAAG,EAAE,MAAM,KAAK,CAAC;AAAA,EAC7C;AAAA,EAEA,OAAO,UACL,OACA,UAAsD,CAAC,GAC7C;AACV,WAAO,IAAI,UAAS,CAAC,iBAAiB,aAAa,WAAW,KAAK,IAAI,KAAK,GAAG,OAAO;AAAA,EACxF;AAAA,EAEA,MAAM,KAAK,MAA6B;AACtC,UAAM,KAAK,MAAM,mBAAmB;AACpC,UAAM,GAAG,UAAU,MAAM,IAAI,WAAW,MAAM,KAAK,YAAY,CAAC,CAAC;AAAA,EACnE;AACF;AAEA,eAAe,qBAAiE;AAI9E,SAAO,oBAAuD,kBAAkB;AAClF;AAEA,SAAS,oBAAuB,WAA+B;AAC7D,SAAO;AAAA;AAAA,IAA0B;AAAA;AACnC;AAEA,SAAS,WAAW,OAA4C;AAC9D,QAAM,OAAO,IAAI,WAAW,MAAM,UAAU;AAC5C,OAAK,IAAI,KAAK;AACd,SAAO;AACT;","names":[]}

package/dist/chunk-4FRFNNBM.js

@@ -0,0 +1,276 @@
+import {
+  RasterImageValidationError,
+  boundedUtf8ByteLength,
+  canonicalizeRasterDataUrl,
+  encodeRasterBase64,
+  normalizeRasterContentType,
+  validateRasterImageBytes
+} from "./chunk-FGZM4FQ6.js";
+
+// src/spreadsheet-address.ts
+var EXCEL_MAX_ROWS = 1048576;
+var EXCEL_MAX_COLUMNS = 16384;
+function columnNameToIndex(name) {
+  if (!/^[A-Za-z]+$/.test(name)) throw new Error(`Invalid column name: ${name}`);
+  let value = 0;
+  for (const character of name.toUpperCase()) {
+    value = value * 26 + character.charCodeAt(0) - 64;
+  }
+  const index = value - 1;
+  if (index < 0 || index >= EXCEL_MAX_COLUMNS) {
+    throw new Error(`Column is outside the XLSX range: ${name}`);
+  }
+  return index;
+}
+function columnIndexToName(index) {
+  assertIntegerInRange(index, 0, EXCEL_MAX_COLUMNS - 1, "column index");
+  let value = index + 1;
+  let result = "";
+  while (value > 0) {
+    const remainder = (value - 1) % 26;
+    result = String.fromCharCode(65 + remainder) + result;
+    value = Math.floor((value - 1) / 26);
+  }
+  return result;
+}
+function parseCellAddress(input) {
+  const match = /^\$?([A-Za-z]+)\$?([1-9]\d*)$/.exec(input.trim());
+  if (!match) throw new Error(`Invalid A1 cell address: ${input}`);
+  const row = Number(match[2]) - 1;
+  if (row < 0 || row >= EXCEL_MAX_ROWS) {
+    throw new Error(`Row is outside the XLSX range: ${input}`);
+  }
+  return { row, col: columnNameToIndex(match[1]) };
+}
+function parseRangeAddress(input) {
+  const parts = input.trim().split(":");
+  if (parts.length > 2 || !parts[0]) throw new Error(`Invalid A1 range: ${input}`);
+  const start = parseCellAddress(parts[0]);
+  const end = parseCellAddress(parts[1] ?? parts[0]);
+  if (end.row < start.row || end.col < start.col) {
+    throw new Error(`Range must run top-left to bottom-right: ${input}`);
+  }
+  return {
+    row: start.row,
+    col: start.col,
+    rowCount: end.row - start.row + 1,
+    colCount: end.col - start.col + 1
+  };
+}
+function formatCellAddress(address) {
+  return `${columnIndexToName(address.col)}${address.row + 1}`;
+}
+function formatRangeAddress(address) {
+  const start = formatCellAddress(address);
+  if (address.rowCount === 1 && address.colCount === 1) return start;
+  return `${start}:${formatCellAddress({
+    row: address.row + address.rowCount - 1,
+    col: address.col + address.colCount - 1
+  })}`;
+}
+function cellKey(row, col) {
+  return row * EXCEL_MAX_COLUMNS + col;
+}
+function assertRange(address) {
+  assertIntegerInRange(address.row, 0, EXCEL_MAX_ROWS - 1, "start row");
+  assertIntegerInRange(address.col, 0, EXCEL_MAX_COLUMNS - 1, "start column");
+  assertIntegerInRange(address.rowCount, 1, EXCEL_MAX_ROWS, "row count");
+  assertIntegerInRange(address.colCount, 1, EXCEL_MAX_COLUMNS, "column count");
+  if (address.row + address.rowCount > EXCEL_MAX_ROWS) throw new Error("Range exceeds XLSX rows");
+  if (address.col + address.colCount > EXCEL_MAX_COLUMNS) {
+    throw new Error("Range exceeds XLSX columns");
+  }
+}
+function assertIntegerInRange(value, min, max, label) {
+  if (!Number.isInteger(value) || value < min || value > max) {
+    throw new Error(`${label} must be an integer between ${min} and ${max}`);
+  }
+}
+
+// src/spreadsheet-image.ts
+var InvalidSpreadsheetImageError = class extends Error {
+  constructor(field, detail) {
+    super(`Invalid spreadsheet ${field}: ${detail}`);
+    this.field = field;
+    this.name = "InvalidSpreadsheetImageError";
+  }
+  code = "INVALID_SPREADSHEET_IMAGE";
+};
+var MAX_IMAGE_BYTES = 32 * 1024 * 1024;
+var MAX_ALT_LENGTH = 1024 * 1024;
+var MAX_PIXEL_VALUE = 1e6;
+var normalizedImages = /* @__PURE__ */ new WeakSet();
+function normalizeSpreadsheetImageConfig(input) {
+  if (typeof input !== "object" || input === null) {
+    throw new InvalidSpreadsheetImageError("image", "must be an object");
+  }
+  if (normalizedImages.has(input)) return input;
+  const hasDataUrl = input.dataUrl !== void 0;
+  const hasBlob = input.blob !== void 0;
+  if (Number(hasDataUrl) + Number(hasBlob) !== 1) {
+    throw new InvalidSpreadsheetImageError(
+      "image source",
+      "requires exactly one source: dataUrl or blob"
+    );
+  }
+  let canonical;
+  let contentType;
+  if (hasDataUrl) {
+    const parsed = parseRasterDataUrl(input.dataUrl);
+    contentType = parsed.contentType;
+    canonical = parsed.canonical;
+  } else {
+    const bytes = copyImageBytes(input.blob);
+    contentType = validateRasterBytes(bytes, input.contentType, "image blob");
+    canonical = `data:${contentType};base64,${encodeRasterBase64(bytes)}`;
+  }
+  if (input.contentType !== void 0 && normalizeRasterMime(input.contentType) !== contentType) {
+    throw new InvalidSpreadsheetImageError("image contentType", "does not match the image bytes");
+  }
+  const anchor = normalizeAnchor(input.anchor);
+  const alt = normalizeAlt(input.alt);
+  const normalized = Object.freeze({
+    dataUrl: canonical,
+    contentType,
+    ...alt === void 0 ? {} : { alt },
+    anchor
+  });
+  normalizedImages.add(normalized);
+  return normalized;
+}
+function spreadsheetImageSource(input) {
+  const normalized = normalizeSpreadsheetImageConfig(input);
+  return normalized.dataUrl;
+}
+function normalizeAnchor(anchor) {
+  if (typeof anchor !== "object" || anchor === null) {
+    throw new InvalidSpreadsheetImageError("image anchor", "must be an object");
+  }
+  const from = anchor.from;
+  const extent = anchor.extent;
+  if (typeof from !== "object" || from === null) {
+    throw new InvalidSpreadsheetImageError("image anchor.from", "must be an object");
+  }
+  if (typeof extent !== "object" || extent === null) {
+    throw new InvalidSpreadsheetImageError("image anchor.extent", "must be an object");
+  }
+  assertInteger(from.row, "image anchor.from.row", 0, 1048575);
+  assertInteger(from.col, "image anchor.from.col", 0, 16383);
+  if (from.rowOffsetPx !== void 0) {
+    assertFiniteInRange(from.rowOffsetPx, "image anchor.from.rowOffsetPx", 0, MAX_PIXEL_VALUE);
+  }
+  if (from.colOffsetPx !== void 0) {
+    assertFiniteInRange(from.colOffsetPx, "image anchor.from.colOffsetPx", 0, MAX_PIXEL_VALUE);
+  }
+  assertFiniteInRange(
+    extent.widthPx,
+    "image anchor.extent.widthPx",
+    Number.MIN_VALUE,
+    MAX_PIXEL_VALUE
+  );
+  assertFiniteInRange(
+    extent.heightPx,
+    "image anchor.extent.heightPx",
+    Number.MIN_VALUE,
+    MAX_PIXEL_VALUE
+  );
+  return Object.freeze({
+    from: Object.freeze({
+      row: from.row,
+      col: from.col,
+      ...from.rowOffsetPx === void 0 ? {} : { rowOffsetPx: from.rowOffsetPx },
+      ...from.colOffsetPx === void 0 ? {} : { colOffsetPx: from.colOffsetPx }
+    }),
+    extent: Object.freeze({ widthPx: extent.widthPx, heightPx: extent.heightPx })
+  });
+}
+function normalizeAlt(value) {
+  if (value === void 0) return void 0;
+  if (typeof value !== "string" || value.length > MAX_ALT_LENGTH || boundedUtf8ByteLength(value, MAX_ALT_LENGTH) > MAX_ALT_LENGTH) {
+    throw new InvalidSpreadsheetImageError("image alt", "must be a bounded string");
+  }
+  for (const character of value) {
+    const codePoint = character.codePointAt(0);
+    if (codePoint < 32 && codePoint !== 9 && codePoint !== 10 && codePoint !== 13 || codePoint >= 55296 && codePoint <= 57343 || codePoint === 65534 || codePoint === 65535) {
+      throw new InvalidSpreadsheetImageError(
+        "image alt",
+        "contains characters forbidden by XML 1.0"
+      );
+    }
+  }
+  return value;
+}
+function parseRasterDataUrl(value) {
+  try {
+    const result = canonicalizeRasterDataUrl(value, MAX_IMAGE_BYTES);
+    return {
+      contentType: result.contentType,
+      canonical: result.canonical
+    };
+  } catch (error) {
+    if (error instanceof RasterImageValidationError) {
+      throw new InvalidSpreadsheetImageError("image dataUrl", error.detail);
+    }
+    throw error;
+  }
+}
+function copyImageBytes(value) {
+  if (!(value instanceof ArrayBuffer)) {
+    throw new InvalidSpreadsheetImageError("image blob", "must be an ArrayBuffer");
+  }
+  const bytes = new Uint8Array(value.slice(0));
+  if (bytes.byteLength === 0 || bytes.byteLength > MAX_IMAGE_BYTES) {
+    throw new InvalidSpreadsheetImageError(
+      "image blob",
+      `must contain between 1 and ${MAX_IMAGE_BYTES} bytes`
+    );
+  }
+  return bytes;
+}
+function normalizeRasterMime(value) {
+  try {
+    return normalizeRasterContentType(value);
+  } catch (error) {
+    if (error instanceof RasterImageValidationError) {
+      throw new InvalidSpreadsheetImageError("image contentType", error.detail);
+    }
+    throw error;
+  }
+}
+function validateRasterBytes(bytes, declaredType, field) {
+  try {
+    return validateRasterImageBytes(bytes, declaredType);
+  } catch (error) {
+    if (error instanceof RasterImageValidationError) {
+      throw new InvalidSpreadsheetImageError(field, error.detail);
+    }
+    throw error;
+  }
+}
+function assertInteger(value, field, min, max) {
+  if (!Number.isInteger(value) || value < min || value > max) {
+    throw new InvalidSpreadsheetImageError(field, `must be an integer from ${min} through ${max}`);
+  }
+}
+function assertFiniteInRange(value, field, min, max) {
+  if (typeof value !== "number" || !Number.isFinite(value) || value < min || value > max) {
+    throw new InvalidSpreadsheetImageError(field, `must be a finite number from ${min} to ${max}`);
+  }
+}
+
+export {
+  EXCEL_MAX_ROWS,
+  EXCEL_MAX_COLUMNS,
+  columnNameToIndex,
+  columnIndexToName,
+  parseCellAddress,
+  parseRangeAddress,
+  formatCellAddress,
+  formatRangeAddress,
+  cellKey,
+  assertRange,
+  InvalidSpreadsheetImageError,
+  normalizeSpreadsheetImageConfig,
+  spreadsheetImageSource
+};
+//# sourceMappingURL=chunk-4FRFNNBM.js.map