@opengeni/contracts 0.40.0 → 0.50.0

package/dist/chunk-LSB7GRLG.js

@@ -0,0 +1,779 @@
+// src/spreadsheet-artifact-date.ts
+var ECMASCRIPT_DATE_MAX_MILLISECONDS = 8640000000000000n;
+function canonicalSpreadsheetDateMilliseconds(value) {
+  const milliseconds = typeof value === "string" ? Date.parse(value) : Number.NaN;
+  if (!Number.isFinite(milliseconds) || new Date(milliseconds).toISOString() !== value) {
+    throw new TypeError("date must be canonical ISO");
+  }
+  return milliseconds;
+}
+function canonicalSpreadsheetDateFromMilliseconds(milliseconds) {
+  if (milliseconds < -ECMASCRIPT_DATE_MAX_MILLISECONDS || milliseconds > ECMASCRIPT_DATE_MAX_MILLISECONDS) {
+    throw new RangeError("date outside supported range");
+  }
+  return new Date(Number(milliseconds)).toISOString();
+}
+
+// src/spreadsheet-artifact-commands.ts
+var SPREADSHEET_ARTIFACT_COMMAND_VERSION = 1;
+var SPREADSHEET_ARTIFACT_COMMAND_MAX_BYTES = 4 * 1024 * 1024;
+var SPREADSHEET_ARTIFACT_COMMAND_MAX_COMMANDS = 4096;
+var SPREADSHEET_ARTIFACT_COMMAND_MAX_CELLS = 1e6;
+var SPREADSHEET_ARTIFACT_COMMAND_MAX_STRING_BYTES = 1 * 1024 * 1024;
+var SPREADSHEET_ARTIFACT_SHEET_NAME_MAX_UTF16_UNITS = 31;
+var MAGIC = new TextEncoder().encode("OGASC001");
+var HEADER_BYTES = 8 + 2 + 2 + 4 + 8;
+var CHECKSUM_BYTES = 8;
+var textEncoder = new TextEncoder();
+var textDecoder = new TextDecoder("utf-8", { fatal: true });
+var LOWER_HEX_ID = /^[0-9a-f]{32}$/u;
+var UINT64_HEX_ZERO = "0".repeat(16);
+var UINT32_MAX = 4294967295;
+var FNV_OFFSET = 0xcbf29ce484222325n;
+var FNV_PRIME = 0x100000001b3n;
+function editableArtifactStableId(value) {
+  return genericStableId(value, "stable id");
+}
+function spreadsheetSheetId(value) {
+  return sheetObjectId(value, "sheet id");
+}
+function encodeSpreadsheetArtifactCommandBatch(input) {
+  const batch = batchRecord(input);
+  const payload = new BinaryWriter(
+    SPREADSHEET_ARTIFACT_COMMAND_MAX_BYTES - HEADER_BYTES - CHECKSUM_BYTES
+  );
+  const context = new CommandContext();
+  for (let index = 0; index < batch.commands.length; index += 1) {
+    const command = ownArrayElement(batch.commands, index, "commands");
+    encodeCommand(payload, command, index, context);
+  }
+  const payloadBytes = payload.finish();
+  const output = new BinaryWriter(SPREADSHEET_ARTIFACT_COMMAND_MAX_BYTES);
+  output.bytes(MAGIC);
+  output.u16(SPREADSHEET_ARTIFACT_COMMAND_VERSION);
+  output.u16(0);
+  output.u32(batch.commands.length);
+  output.u64(BigInt(payloadBytes.byteLength));
+  output.bytes(payloadBytes);
+  output.u64(fnv1a64(output.view()));
+  return output.finish();
+}
+function decodeSpreadsheetArtifactCommandBatch(bytes) {
+  if (!(bytes instanceof Uint8Array)) {
+    throw new TypeError("spreadsheet command bytes must be a Uint8Array");
+  }
+  if (bytes.byteLength > SPREADSHEET_ARTIFACT_COMMAND_MAX_BYTES) {
+    throw new RangeError("spreadsheet command envelope exceeds its byte limit");
+  }
+  if (bytes.byteLength < HEADER_BYTES + CHECKSUM_BYTES) {
+    throw new TypeError("truncated spreadsheet command envelope");
+  }
+  const header = new BinaryReader(bytes);
+  if (!equalBytes(header.bytes(MAGIC.byteLength), MAGIC)) {
+    throw new TypeError("invalid spreadsheet command magic");
+  }
+  const version = header.u16();
+  if (version !== SPREADSHEET_ARTIFACT_COMMAND_VERSION) {
+    throw new TypeError(`unsupported spreadsheet command version: ${version}`);
+  }
+  if (header.u16() !== 0) {
+    throw new TypeError("spreadsheet command reserved flags must be zero");
+  }
+  const commandCount = header.u32();
+  if (commandCount < 1 || commandCount > SPREADSHEET_ARTIFACT_COMMAND_MAX_COMMANDS) {
+    throw new RangeError("spreadsheet command count is outside its limit");
+  }
+  const payloadLength = safeLength(header.u64(), "spreadsheet command payload");
+  const expectedLength = HEADER_BYTES + payloadLength + CHECKSUM_BYTES;
+  if (bytes.byteLength < expectedLength) {
+    throw new TypeError("truncated spreadsheet command envelope");
+  }
+  if (bytes.byteLength > expectedLength) {
+    throw new TypeError("spreadsheet command envelope contains trailing bytes");
+  }
+  const advertisedChecksum = readU64At(bytes, expectedLength - CHECKSUM_BYTES);
+  const actualChecksum = fnv1a64(bytes.subarray(0, expectedLength - CHECKSUM_BYTES));
+  if (advertisedChecksum !== actualChecksum) {
+    throw new TypeError("spreadsheet command checksum does not match");
+  }
+  const payload = new BinaryReader(bytes.subarray(HEADER_BYTES, HEADER_BYTES + payloadLength));
+  const context = new CommandContext();
+  const commands = [];
+  for (let index = 0; index < commandCount; index += 1) {
+    commands.push(decodeCommand(payload, index, context));
+  }
+  payload.done("spreadsheet command payload contains trailing bytes");
+  return Object.freeze({
+    version: SPREADSHEET_ARTIFACT_COMMAND_VERSION,
+    commands: Object.freeze(commands)
+  });
+}
+function assertCanonicalSpreadsheetArtifactCommandBytes(bytes) {
+  const canonical = encodeSpreadsheetArtifactCommandBatch(
+    decodeSpreadsheetArtifactCommandBatch(bytes)
+  );
+  if (!equalBytes(bytes, canonical)) {
+    throw new TypeError("spreadsheet command envelope is not canonical");
+  }
+  return bytes;
+}
+var CommandContext = class {
+  createdByIndex = /* @__PURE__ */ new Map();
+  createdSheetIds = /* @__PURE__ */ new Set();
+  totalCells = 0;
+  registerCreate(index, sheetId) {
+    if (this.createdSheetIds.has(sheetId)) {
+      throw commandError(index, "sheet id is created more than once in the batch");
+    }
+    this.createdByIndex.set(index, sheetId);
+    this.createdSheetIds.add(sheetId);
+  }
+  addCells(index, rows, columns) {
+    const count = rows * columns;
+    if (!Number.isSafeInteger(count) || count < 1) {
+      throw commandError(index, "cell block dimensions are invalid");
+    }
+    const next = this.totalCells + count;
+    if (!Number.isSafeInteger(next) || next > SPREADSHEET_ARTIFACT_COMMAND_MAX_CELLS) {
+      throw commandError(index, "cell count exceeds its transaction limit");
+    }
+    this.totalCells = next;
+    return count;
+  }
+};
+function encodeCommand(writer, value, index, context) {
+  const command = plainRecord(value, `spreadsheet command ${index}`);
+  switch (command.kind) {
+    case "sheet.create": {
+      exactKeys(command, ["after", "kind", "name", "sheetId"], `spreadsheet command ${index}`);
+      const sheetId = sheetObjectId(command.sheetId, `spreadsheet command ${index} sheetId`);
+      const name = sheetName(command.name, index);
+      writer.u8(0);
+      writer.stableId(sheetId);
+      writer.string(name, SPREADSHEET_ARTIFACT_COMMAND_MAX_STRING_BYTES);
+      if (command.after === null) {
+        writer.u8(0);
+      } else {
+        writer.u8(1);
+        encodeSheetPrecondition(writer, command.after, index, context);
+      }
+      context.registerCreate(index, sheetId);
+      break;
+    }
+    case "sheet.rename": {
+      exactKeys(command, ["kind", "name", "sheet"], `spreadsheet command ${index}`);
+      writer.u8(1);
+      encodeSheetPrecondition(writer, command.sheet, index, context);
+      writer.string(sheetName(command.name, index), SPREADSHEET_ARTIFACT_COMMAND_MAX_STRING_BYTES);
+      break;
+    }
+    case "sheet.delete": {
+      exactKeys(command, ["kind", "sheet"], `spreadsheet command ${index}`);
+      writer.u8(2);
+      encodeSheetPrecondition(writer, command.sheet, index, context);
+      break;
+    }
+    case "cells.set": {
+      exactKeys(
+        command,
+        ["anchor", "cells", "columns", "kind", "rows", "sheet"],
+        `spreadsheet command ${index}`
+      );
+      const anchor = point(command.anchor, `spreadsheet command ${index} anchor`);
+      const rows = positiveU32(command.rows, `spreadsheet command ${index} rows`);
+      const columns = positiveU32(command.columns, `spreadsheet command ${index} columns`);
+      assertExtent(anchor.row, rows, "row", index);
+      assertExtent(anchor.column, columns, "column", index);
+      const count = context.addCells(index, rows, columns);
+      if (!Array.isArray(command.cells) || command.cells.length !== count) {
+        throw commandError(index, `cells must contain exactly ${count} row-major values`);
+      }
+      writer.u8(3);
+      encodeSheetPrecondition(writer, command.sheet, index, context);
+      writer.u32(anchor.row);
+      writer.u32(anchor.column);
+      writer.u32(rows);
+      writer.u32(columns);
+      for (let cellIndex = 0; cellIndex < count; cellIndex += 1) {
+        writer.cell(
+          ownArrayElement(command.cells, cellIndex, `spreadsheet command ${index} cells`)
+        );
+      }
+      break;
+    }
+    case "range.clear": {
+      exactKeys(command, ["kind", "range", "sheet"], `spreadsheet command ${index}`);
+      const range = cellRange(command.range, index);
+      writer.u8(4);
+      encodeSheetPrecondition(writer, command.sheet, index, context);
+      writer.u32(range.start.row);
+      writer.u32(range.start.column);
+      writer.u32(range.end.row);
+      writer.u32(range.end.column);
+      break;
+    }
+    default:
+      throw commandError(index, "unknown command kind");
+  }
+}
+function decodeCommand(reader, index, context) {
+  switch (reader.u8()) {
+    case 0: {
+      const sheetId = reader.sheetObjectId();
+      const name = decodedSheetName(
+        reader.string(SPREADSHEET_ARTIFACT_COMMAND_MAX_STRING_BYTES),
+        index
+      );
+      const afterFlag = reader.u8();
+      if (afterFlag > 1) throw commandError(index, "after presence flag is invalid");
+      const after = afterFlag === 1 ? decodeSheetPrecondition(reader, index, context) : null;
+      context.registerCreate(index, sheetId);
+      return Object.freeze({ kind: "sheet.create", sheetId, name, after });
+    }
+    case 1:
+      return Object.freeze({
+        kind: "sheet.rename",
+        sheet: decodeSheetPrecondition(reader, index, context),
+        name: decodedSheetName(reader.string(SPREADSHEET_ARTIFACT_COMMAND_MAX_STRING_BYTES), index)
+      });
+    case 2:
+      return Object.freeze({
+        kind: "sheet.delete",
+        sheet: decodeSheetPrecondition(reader, index, context)
+      });
+    case 3: {
+      const sheet = decodeSheetPrecondition(reader, index, context);
+      const anchor = frozenPoint(reader.u32(), reader.u32());
+      const rows = reader.u32();
+      const columns = reader.u32();
+      if (rows === 0 || columns === 0) {
+        throw commandError(index, "cell block dimensions must be nonzero");
+      }
+      assertExtent(anchor.row, rows, "row", index);
+      assertExtent(anchor.column, columns, "column", index);
+      const count = context.addCells(index, rows, columns);
+      const cells = [];
+      for (let cellIndex = 0; cellIndex < count; cellIndex += 1) cells.push(reader.cell());
+      return Object.freeze({
+        kind: "cells.set",
+        sheet,
+        anchor,
+        rows,
+        columns,
+        cells: Object.freeze(cells)
+      });
+    }
+    case 4: {
+      const sheet = decodeSheetPrecondition(reader, index, context);
+      const start = frozenPoint(reader.u32(), reader.u32());
+      const end = frozenPoint(reader.u32(), reader.u32());
+      if (start.row > end.row || start.column > end.column) {
+        throw commandError(index, "clear range endpoints are not ordered");
+      }
+      return Object.freeze({
+        kind: "range.clear",
+        sheet,
+        range: Object.freeze({ start, end })
+      });
+    }
+    default:
+      throw commandError(index, "unknown binary command tag");
+  }
+}
+function encodeSheetPrecondition(writer, value, commandIndex, context) {
+  const input = plainRecord(value, `spreadsheet command ${commandIndex} sheet precondition`);
+  if (input.kind === "generation") {
+    exactKeys(
+      input,
+      ["creationOperationId", "kind", "sheetId"],
+      `spreadsheet command ${commandIndex} sheet generation`
+    );
+    writer.u8(0);
+    writer.stableId(sheetObjectId(input.sheetId, "sheet generation sheetId"));
+    writer.stableId(genericStableId(input.creationOperationId, "sheet creation operation id"));
+    return;
+  }
+  if (input.kind === "created-in-batch") {
+    exactKeys(
+      input,
+      ["createCommandIndex", "kind", "sheetId"],
+      `spreadsheet command ${commandIndex} prior-create precondition`
+    );
+    const sheetId = sheetObjectId(input.sheetId, "prior-create sheetId");
+    const createCommandIndex = nonnegativeU32(
+      input.createCommandIndex,
+      "prior-create command index"
+    );
+    assertPriorCreate(context, commandIndex, createCommandIndex, sheetId);
+    writer.u8(1);
+    writer.stableId(sheetId);
+    writer.u32(createCommandIndex);
+    return;
+  }
+  throw commandError(commandIndex, "unknown sheet precondition kind");
+}
+function decodeSheetPrecondition(reader, commandIndex, context) {
+  switch (reader.u8()) {
+    case 0:
+      return Object.freeze({
+        kind: "generation",
+        sheetId: reader.sheetObjectId(),
+        creationOperationId: reader.genericStableId()
+      });
+    case 1: {
+      const sheetId = reader.sheetObjectId();
+      const createCommandIndex = reader.u32();
+      assertPriorCreate(context, commandIndex, createCommandIndex, sheetId);
+      return Object.freeze({
+        kind: "created-in-batch",
+        sheetId,
+        createCommandIndex
+      });
+    }
+    default:
+      throw commandError(commandIndex, "unknown sheet precondition tag");
+  }
+}
+function assertPriorCreate(context, commandIndex, createCommandIndex, sheetId) {
+  if (createCommandIndex >= commandIndex) {
+    throw commandError(commandIndex, "prior-create reference must point to an earlier command");
+  }
+  if (context.createdByIndex.get(createCommandIndex) !== sheetId) {
+    throw commandError(
+      commandIndex,
+      "prior-create reference must match the referenced create command and sheet id"
+    );
+  }
+}
+function batchRecord(input) {
+  const batch = plainRecord(input, "spreadsheet command batch");
+  exactKeys(batch, ["commands", "version"], "spreadsheet command batch");
+  if (batch.version !== SPREADSHEET_ARTIFACT_COMMAND_VERSION) {
+    throw new TypeError("spreadsheet command batch version must be 1");
+  }
+  if (!Array.isArray(batch.commands)) throw new TypeError("commands must be an array");
+  if (batch.commands.length < 1 || batch.commands.length > SPREADSHEET_ARTIFACT_COMMAND_MAX_COMMANDS) {
+    throw new RangeError("spreadsheet command count is outside its limit");
+  }
+  return input;
+}
+function cellRange(value, index) {
+  const range = plainRecord(value, `spreadsheet command ${index} range`);
+  exactKeys(range, ["end", "start"], `spreadsheet command ${index} range`);
+  const start = point(range.start, `spreadsheet command ${index} range start`);
+  const end = point(range.end, `spreadsheet command ${index} range end`);
+  if (start.row > end.row || start.column > end.column) {
+    throw commandError(index, "clear range endpoints are not ordered");
+  }
+  return { start, end };
+}
+function point(value, label) {
+  const input = plainRecord(value, label);
+  exactKeys(input, ["column", "row"], label);
+  return {
+    row: nonnegativeU32(input.row, `${label} row`),
+    column: nonnegativeU32(input.column, `${label} column`)
+  };
+}
+function frozenPoint(row, column) {
+  return Object.freeze({ row, column });
+}
+function sheetName(value, index) {
+  if (typeof value !== "string") throw commandError(index, "sheet name must be a string");
+  return decodedSheetName(value, index);
+}
+function decodedSheetName(value, index) {
+  const bytes = strictUtf8(value, "sheet name");
+  const forbidden = /[\\/?*[\]:\0]/u.test(value);
+  if (bytes.byteLength === 0 || value.trim() !== value || value.length > SPREADSHEET_ARTIFACT_SHEET_NAME_MAX_UTF16_UNITS || forbidden) {
+    throw commandError(index, "sheet name does not match the public spreadsheet model");
+  }
+  return value;
+}
+function genericStableId(value, label) {
+  if (typeof value !== "string" || !LOWER_HEX_ID.test(value) || /^0+$/u.test(value)) {
+    throw new TypeError(`${label} must be nonzero fixed-width lowercase hexadecimal text`);
+  }
+  return value;
+}
+function sheetObjectId(value, label) {
+  const id = genericStableId(value, label);
+  if (id.slice(0, 16) === UINT64_HEX_ZERO || id.slice(16) === UINT64_HEX_ZERO) {
+    throw new TypeError(`${label} must have a nonzero namespace and counter`);
+  }
+  return id;
+}
+function positiveU32(value, label) {
+  const output = nonnegativeU32(value, label);
+  if (output === 0) throw new TypeError(`${label} must be positive`);
+  return output;
+}
+function nonnegativeU32(value, label) {
+  if (!Number.isInteger(value) || value < 0 || value > UINT32_MAX) {
+    throw new TypeError(`${label} must be a uint32`);
+  }
+  return value;
+}
+function assertExtent(start, length, axis, index) {
+  if (length - 1 > UINT32_MAX - start) {
+    throw commandError(index, `${axis} extent exceeds uint32 coordinates`);
+  }
+}
+function safeLength(value, label) {
+  if (value > BigInt(Number.MAX_SAFE_INTEGER)) throw new RangeError(`${label} length is unsafe`);
+  const length = Number(value);
+  if (length > SPREADSHEET_ARTIFACT_COMMAND_MAX_BYTES - HEADER_BYTES - CHECKSUM_BYTES) {
+    throw new RangeError(`${label} exceeds its byte limit`);
+  }
+  return length;
+}
+function plainRecord(value, label) {
+  if (typeof value !== "object" || value === null || Array.isArray(value) || Object.getPrototypeOf(value) !== Object.prototype) {
+    throw new TypeError(`${label} must be a plain record`);
+  }
+  return value;
+}
+function exactKeys(value, expected, label) {
+  const keys = Reflect.ownKeys(value);
+  if (keys.some((key) => typeof key !== "string")) {
+    throw new TypeError(`${label} contains unsupported symbol fields`);
+  }
+  const actual = keys.sort(compareCodeUnits);
+  if (actual.length !== expected.length || actual.some((key, index) => key !== expected[index])) {
+    throw new TypeError(`${label} fields must be exactly: ${expected.join(", ")}`);
+  }
+  for (const key of actual) {
+    const descriptor = Object.getOwnPropertyDescriptor(value, key);
+    if (!descriptor || !("value" in descriptor) || !descriptor.enumerable) {
+      throw new TypeError(`${label} fields must be enumerable data properties`);
+    }
+  }
+}
+function ownArrayElement(value, index, label) {
+  if (!Object.hasOwn(value, index)) throw new TypeError(`${label} must be dense`);
+  return value[index];
+}
+function commandError(index, message) {
+  return new TypeError(`spreadsheet command ${index}: ${message}`);
+}
+function strictUtf8(value, label) {
+  for (let index = 0; index < value.length; index += 1) {
+    const code = value.charCodeAt(index);
+    if (code >= 55296 && code <= 56319) {
+      const next = value.charCodeAt(index + 1);
+      if (!(next >= 56320 && next <= 57343)) {
+        throw new TypeError(`${label} contains an unpaired surrogate`);
+      }
+      index += 1;
+    } else if (code >= 56320 && code <= 57343) {
+      throw new TypeError(`${label} contains an unpaired surrogate`);
+    }
+  }
+  return textEncoder.encode(value);
+}
+function compareCodeUnits(left, right) {
+  return left < right ? -1 : left > right ? 1 : 0;
+}
+function fnv1a64(bytes) {
+  let hash = FNV_OFFSET;
+  for (const byte of bytes) {
+    hash ^= BigInt(byte);
+    hash = BigInt.asUintN(64, hash * FNV_PRIME);
+  }
+  return hash;
+}
+function equalBytes(left, right) {
+  return left.byteLength === right.byteLength && left.every((value, index) => value === right[index]);
+}
+function readU64At(bytes, offset) {
+  let value = 0n;
+  for (let index = 0; index < 8; index += 1) {
+    value |= BigInt(bytes[offset + index]) << BigInt(index * 8);
+  }
+  return value;
+}
+var STANDARD_ERROR_TAGS = Object.freeze({
+  "#NULL!": 0,
+  "#DIV/0!": 1,
+  "#VALUE!": 2,
+  "#REF!": 3,
+  "#NAME?": 4,
+  "#NUM!": 5,
+  "#N/A": 6,
+  "#SPILL!": 7,
+  "#CALC!": 8
+});
+var STANDARD_ERRORS = Object.freeze([
+  "#NULL!",
+  "#DIV/0!",
+  "#VALUE!",
+  "#REF!",
+  "#NAME?",
+  "#NUM!",
+  "#N/A",
+  "#SPILL!",
+  "#CALC!"
+]);
+var BinaryWriter = class {
+  constructor(maximum) {
+    this.maximum = maximum;
+    this.buffer = new Uint8Array(Math.min(1024, maximum));
+    this.viewBuffer = new DataView(this.buffer.buffer);
+  }
+  buffer;
+  viewBuffer;
+  length = 0;
+  view() {
+    return this.buffer.subarray(0, this.length);
+  }
+  finish() {
+    return this.buffer.slice(0, this.length);
+  }
+  u8(value) {
+    this.reserve(1);
+    this.viewBuffer.setUint8(this.length, value);
+    this.length += 1;
+  }
+  u16(value) {
+    this.reserve(2);
+    this.viewBuffer.setUint16(this.length, value, true);
+    this.length += 2;
+  }
+  u32(value) {
+    this.reserve(4);
+    this.viewBuffer.setUint32(this.length, value, true);
+    this.length += 4;
+  }
+  u64(value) {
+    this.reserve(8);
+    this.viewBuffer.setBigUint64(this.length, value, true);
+    this.length += 8;
+  }
+  i64(value) {
+    this.reserve(8);
+    this.viewBuffer.setBigInt64(this.length, value, true);
+    this.length += 8;
+  }
+  f64(value) {
+    this.reserve(8);
+    this.viewBuffer.setFloat64(this.length, value === 0 ? 0 : value, true);
+    this.length += 8;
+  }
+  stableId(value) {
+    this.u64(BigInt(`0x${value.slice(16)}`));
+    this.u64(BigInt(`0x${value.slice(0, 16)}`));
+  }
+  string(value, maximum) {
+    const bytes = strictUtf8(value, "spreadsheet string");
+    if (bytes.byteLength > maximum)
+      throw new RangeError("spreadsheet string exceeds its byte limit");
+    this.u32(bytes.byteLength);
+    this.bytes(bytes);
+  }
+  cell(value) {
+    if (isFormulaCell(value)) {
+      const cell = plainRecord(value, "formula cell");
+      exactKeys(cell, ["cached", "formula"], "formula cell");
+      if (typeof cell.formula !== "string" || cell.formula.length === 0) {
+        throw new TypeError("formula source must be a nonempty string");
+      }
+      this.u8(1);
+      this.string(cell.formula, SPREADSHEET_ARTIFACT_COMMAND_MAX_STRING_BYTES);
+      this.scalar(cell.cached);
+      return;
+    }
+    this.u8(0);
+    this.scalar(value);
+  }
+  scalar(value) {
+    if (value === null) {
+      this.u8(0);
+    } else if (value === false) {
+      this.u8(1);
+    } else if (value === true) {
+      this.u8(2);
+    } else if (typeof value === "number") {
+      if (!Number.isFinite(value)) throw new TypeError("spreadsheet numbers must be finite");
+      this.u8(3);
+      this.f64(value);
+    } else if (typeof value === "string") {
+      this.u8(4);
+      this.string(value, SPREADSHEET_ARTIFACT_COMMAND_MAX_STRING_BYTES);
+    } else if (isDateValue(value)) {
+      const date = plainRecord(value, "date cell");
+      exactKeys(date, ["date"], "date cell");
+      this.u8(6);
+      this.i64(BigInt(canonicalDateMilliseconds(date.date)));
+    } else if (isFormulaError(value)) {
+      const error = plainRecord(value, "formula error");
+      exactKeys(error, ["error"], "formula error");
+      this.u8(5);
+      const tag = STANDARD_ERROR_TAGS[error.error];
+      if (tag !== void 0) {
+        this.u8(tag);
+      } else {
+        this.u8(9);
+        this.string(error.error, SPREADSHEET_ARTIFACT_COMMAND_MAX_STRING_BYTES);
+      }
+    } else {
+      throw new TypeError("spreadsheet cell has an unsupported value shape");
+    }
+  }
+  bytes(value) {
+    this.reserve(value.byteLength);
+    this.buffer.set(value, this.length);
+    this.length += value.byteLength;
+  }
+  reserve(additional) {
+    const needed = this.length + additional;
+    if (!Number.isSafeInteger(needed) || needed > this.maximum) {
+      throw new RangeError("spreadsheet command envelope exceeds its byte limit");
+    }
+    if (needed <= this.buffer.byteLength) return;
+    let size = Math.max(1, this.buffer.byteLength);
+    while (size < needed) size = Math.min(this.maximum, size * 2);
+    const next = new Uint8Array(size);
+    next.set(this.buffer.subarray(0, this.length));
+    this.buffer = next;
+    this.viewBuffer = new DataView(next.buffer);
+  }
+};
+var BinaryReader = class {
+  constructor(input) {
+    this.input = input;
+  }
+  offset = 0;
+  u8() {
+    return this.bytes(1)[0];
+  }
+  u16() {
+    const bytes = this.bytes(2);
+    return bytes[0] | bytes[1] << 8;
+  }
+  u32() {
+    const bytes = this.bytes(4);
+    return bytes[0] + bytes[1] * 2 ** 8 + bytes[2] * 2 ** 16 + bytes[3] * 2 ** 24;
+  }
+  u64() {
+    const bytes = this.bytes(8);
+    let value = 0n;
+    for (let index = 0; index < 8; index += 1) {
+      value |= BigInt(bytes[index]) << BigInt(index * 8);
+    }
+    return value;
+  }
+  i64() {
+    const bytes = this.bytes(8);
+    return new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getBigInt64(0, true);
+  }
+  f64() {
+    const bytes = this.bytes(8);
+    const value = new DataView(bytes.buffer, bytes.byteOffset, bytes.byteLength).getFloat64(
+      0,
+      true
+    );
+    if (!Number.isFinite(value)) throw new TypeError("spreadsheet numbers must be finite");
+    if (Object.is(value, -0)) {
+      throw new TypeError("spreadsheet numbers must encode zero with a positive sign");
+    }
+    return value;
+  }
+  sheetObjectId() {
+    return sheetObjectId(this.stableIdText(), "sheet id");
+  }
+  genericStableId() {
+    return genericStableId(this.stableIdText(), "stable id");
+  }
+  string(maximum) {
+    const length = this.u32();
+    if (length > maximum) throw new RangeError("spreadsheet string exceeds its byte limit");
+    return textDecoder.decode(this.bytes(length));
+  }
+  cell() {
+    const formulaTag = this.u8();
+    if (formulaTag > 1) throw new TypeError("spreadsheet formula presence tag is invalid");
+    const formula = formulaTag === 1 ? this.nonemptyFormula(this.string(SPREADSHEET_ARTIFACT_COMMAND_MAX_STRING_BYTES)) : null;
+    const cached = this.scalar();
+    return formula === null ? cached : Object.freeze({ formula, cached });
+  }
+  done(message) {
+    if (this.offset !== this.input.byteLength) throw new TypeError(message);
+  }
+  bytes(length) {
+    const end = this.offset + length;
+    if (!Number.isSafeInteger(length) || length < 0 || end > this.input.byteLength) {
+      throw new TypeError("truncated spreadsheet command envelope");
+    }
+    const result = this.input.subarray(this.offset, end);
+    this.offset = end;
+    return result;
+  }
+  stableIdText() {
+    const counter = this.u64().toString(16).padStart(16, "0");
+    const namespace = this.u64().toString(16).padStart(16, "0");
+    return `${namespace}${counter}`;
+  }
+  nonemptyFormula(value) {
+    if (value.length === 0) throw new TypeError("formula source must not be empty");
+    return value;
+  }
+  scalar() {
+    switch (this.u8()) {
+      case 0:
+        return null;
+      case 1:
+        return false;
+      case 2:
+        return true;
+      case 3:
+        return this.f64();
+      case 4:
+        return this.string(SPREADSHEET_ARTIFACT_COMMAND_MAX_STRING_BYTES);
+      case 5: {
+        const tag = this.u8();
+        if (tag <= 8) return Object.freeze({ error: STANDARD_ERRORS[tag] });
+        if (tag === 9) {
+          return Object.freeze({
+            error: this.string(SPREADSHEET_ARTIFACT_COMMAND_MAX_STRING_BYTES)
+          });
+        }
+        throw new TypeError("spreadsheet formula error tag is invalid");
+      }
+      case 6:
+        return Object.freeze({
+          date: canonicalSpreadsheetDateFromMilliseconds(this.i64())
+        });
+      default:
+        throw new TypeError("spreadsheet scalar tag is invalid");
+    }
+  }
+};
+function isFormulaCell(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.hasOwn(value, "formula");
+}
+function isFormulaError(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && typeof value.error === "string";
+}
+function isDateValue(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) && Object.hasOwn(value, "date");
+}
+function canonicalDateMilliseconds(value) {
+  return canonicalSpreadsheetDateMilliseconds(value);
+}
+
+export {
+  canonicalSpreadsheetDateMilliseconds,
+  canonicalSpreadsheetDateFromMilliseconds,
+  SPREADSHEET_ARTIFACT_COMMAND_VERSION,
+  SPREADSHEET_ARTIFACT_COMMAND_MAX_BYTES,
+  SPREADSHEET_ARTIFACT_COMMAND_MAX_COMMANDS,
+  SPREADSHEET_ARTIFACT_COMMAND_MAX_CELLS,
+  SPREADSHEET_ARTIFACT_COMMAND_MAX_STRING_BYTES,
+  SPREADSHEET_ARTIFACT_SHEET_NAME_MAX_UTF16_UNITS,
+  editableArtifactStableId,
+  spreadsheetSheetId,
+  encodeSpreadsheetArtifactCommandBatch,
+  decodeSpreadsheetArtifactCommandBatch,
+  assertCanonicalSpreadsheetArtifactCommandBytes
+};
+//# sourceMappingURL=chunk-LSB7GRLG.js.map