@stamprally/core 0.1.0

package/dist/index.cjs

@@ -0,0 +1,1375 @@
+'use strict';
+
+// src/engine/evaluate.ts
+var EARTH_RADIUS_METERS = 6371e3;
+function toRadians(degrees) {
+  return degrees * Math.PI / 180;
+}
+function calculateDistanceMeters(latitudeA, longitudeA, latitudeB, longitudeB) {
+  const latitudeDelta = toRadians(latitudeB - latitudeA);
+  const longitudeDelta = toRadians(longitudeB - longitudeA);
+  const latitudeARadians = toRadians(latitudeA);
+  const latitudeBRadians = toRadians(latitudeB);
+  const haversine = Math.sin(latitudeDelta / 2) ** 2 + Math.cos(latitudeARadians) * Math.cos(latitudeBRadians) * Math.sin(longitudeDelta / 2) ** 2;
+  return 2 * EARTH_RADIUS_METERS * Math.asin(Math.sqrt(Math.min(1, haversine)));
+}
+function isValidCoordinate(latitude, longitude) {
+  return Number.isFinite(latitude) && latitude >= -90 && latitude <= 90 && Number.isFinite(longitude) && longitude >= -180 && longitude <= 180;
+}
+function contextTypeMismatch(conditionType, expectedContextType, actualContextType) {
+  return {
+    ok: false,
+    error: {
+      code: "CONDITION_MISMATCH",
+      conditionType,
+      reason: "CONTEXT_TYPE_MISMATCH",
+      expectedContextType,
+      actualContextType
+    }
+  };
+}
+function assertNever(value) {
+  throw new Error(`Unexpected condition: ${JSON.stringify(value)}`);
+}
+function evaluateConditionDetailed(condition, context, now) {
+  switch (condition.type) {
+    case "instant":
+      return context.type === "instant" ? { ok: true, value: { conditionType: "instant" } } : contextTypeMismatch("instant", "instant", context.type);
+    case "token":
+      if (context.type !== "token") {
+        return contextTypeMismatch("token", "token", context.type);
+      }
+      return context.token === condition.token ? { ok: true, value: { conditionType: "token" } } : {
+        ok: false,
+        error: {
+          code: "CONDITION_MISMATCH",
+          conditionType: "token",
+          reason: "TOKEN_MISMATCH"
+        }
+      };
+    case "geo": {
+      if (context.type !== "geo") {
+        return contextTypeMismatch("geo", "geo", context.type);
+      }
+      if (!isValidCoordinate(condition.latitude, condition.longitude) || !isValidCoordinate(context.currentLatitude, context.currentLongitude) || !Number.isFinite(condition.radiusMeters) || condition.radiusMeters < 0) {
+        return {
+          ok: false,
+          error: {
+            code: "CONDITION_MISMATCH",
+            conditionType: "geo",
+            reason: "INVALID_GEO_INPUT"
+          }
+        };
+      }
+      const distanceMeters = calculateDistanceMeters(
+        condition.latitude,
+        condition.longitude,
+        context.currentLatitude,
+        context.currentLongitude
+      );
+      if (distanceMeters <= condition.radiusMeters) {
+        return { ok: true, value: { conditionType: "geo", distanceMeters } };
+      }
+      return {
+        ok: false,
+        error: {
+          code: "CONDITION_MISMATCH",
+          conditionType: "geo",
+          reason: "OUTSIDE_RADIUS",
+          distanceMeters,
+          radiusMeters: condition.radiusMeters,
+          differenceMeters: distanceMeters - condition.radiusMeters
+        }
+      };
+    }
+    case "composite": {
+      if (context.type !== "composite") {
+        return contextTypeMismatch("composite", "composite", context.type);
+      }
+      if (condition.conditions.length !== context.contexts.length) {
+        return {
+          ok: false,
+          error: {
+            code: "CONDITION_MISMATCH",
+            conditionType: "composite",
+            reason: "CONTEXT_LENGTH_MISMATCH",
+            expectedCount: condition.conditions.length,
+            actualCount: context.contexts.length
+          }
+        };
+      }
+      const failures = [];
+      let matchedCount = 0;
+      for (const [index, childCondition] of condition.conditions.entries()) {
+        const childContext = context.contexts[index];
+        if (childContext === void 0) continue;
+        const result = evaluateConditionDetailed(childCondition, childContext, now);
+        if (result.ok) matchedCount += 1;
+        else failures.push({ index, error: result.error });
+      }
+      if (condition.operator === "AND" && failures.length === 0) {
+        return { ok: true, value: { conditionType: "composite" } };
+      }
+      if (condition.operator === "OR" && matchedCount > 0) {
+        return { ok: true, value: { conditionType: "composite" } };
+      }
+      return {
+        ok: false,
+        error: {
+          code: "CONDITION_MISMATCH",
+          conditionType: "composite",
+          reason: condition.operator === "AND" ? "AND_CHILD_FAILED" : "OR_ALL_FAILED",
+          failures
+        }
+      };
+    }
+    case "time_window": {
+      const startsAt = Date.parse(condition.startsAt);
+      const endsAt = Date.parse(condition.endsAt);
+      const currentTime = Date.parse(now);
+      if (!Number.isFinite(currentTime)) {
+        return {
+          ok: false,
+          error: {
+            code: "CONDITION_MISMATCH",
+            conditionType: "time_window",
+            reason: "INVALID_NOW",
+            now,
+            startsAt: condition.startsAt,
+            endsAt: condition.endsAt
+          }
+        };
+      }
+      if (!Number.isFinite(startsAt) || !Number.isFinite(endsAt) || startsAt > endsAt) {
+        return {
+          ok: false,
+          error: {
+            code: "CONDITION_MISMATCH",
+            conditionType: "time_window",
+            reason: "INVALID_TIME_WINDOW",
+            now,
+            startsAt: condition.startsAt,
+            endsAt: condition.endsAt
+          }
+        };
+      }
+      if (currentTime < startsAt || currentTime > endsAt) {
+        return {
+          ok: false,
+          error: {
+            code: "CONDITION_MISMATCH",
+            conditionType: "time_window",
+            reason: currentTime < startsAt ? "BEFORE_START" : "AFTER_END",
+            now,
+            startsAt: condition.startsAt,
+            endsAt: condition.endsAt
+          }
+        };
+      }
+      const childResult = evaluateConditionDetailed(condition.condition, context, now);
+      return childResult.ok ? { ok: true, value: { conditionType: "time_window" } } : childResult;
+    }
+    default:
+      return assertNever(condition);
+  }
+}
+function evaluateCondition(condition, context, now) {
+  return evaluateConditionDetailed(condition, context, now ?? "").ok;
+}
+
+// src/engine/order.ts
+function getOrderedStamps(config) {
+  return config.stamps.map((stamp, index) => ({ stamp, index })).sort((left, right) => {
+    const orderDifference = (left.stamp.order ?? Number.POSITIVE_INFINITY) - (right.stamp.order ?? Number.POSITIVE_INFINITY);
+    return orderDifference === 0 ? left.index - right.index : orderDifference;
+  }).map(({ stamp }) => stamp);
+}
+
+// src/engine/progress.ts
+function calculateProgress(state, config) {
+  const configuredStampIds = new Set(config.stamps.map((stamp) => stamp.id));
+  const acquiredStampIds = new Set(
+    state.records.map((record) => record.stampId).filter((stampId) => configuredStampIds.has(stampId))
+  );
+  const total = config.stamps.length;
+  const acquired = acquiredStampIds.size;
+  const isCompleted = total > 0 && acquired === total;
+  const remainingStamps = config.stamps.filter((stamp) => !acquiredStampIds.has(stamp.id));
+  const nextAvailableStamps = config.isSequential === true ? getOrderedStamps(config).filter((stamp) => !acquiredStampIds.has(stamp.id)).slice(0, 1) : remainingStamps;
+  return {
+    acquired,
+    total,
+    percentage: total === 0 ? 0 : acquired / total * 100,
+    isCompleted,
+    isComplete: isCompleted,
+    nextAvailableStamps
+  };
+}
+
+// src/detectors/types.ts
+function createDetectorError(detector, code, message, cause) {
+  return cause === void 0 ? { detector, code, message } : { detector, code, message, cause };
+}
+function mapBrowserError(detector, error) {
+  if (typeof DOMException !== "undefined" && error instanceof DOMException) {
+    if (error.name === "NotAllowedError" || error.name === "SecurityError") {
+      return createDetectorError(
+        detector,
+        "PERMISSION_DENIED",
+        `${detector} permission was denied.`,
+        error
+      );
+    }
+    if (error.name === "AbortError") {
+      return createDetectorError(detector, "ABORTED", `${detector} detection was aborted.`, error);
+    }
+    if (error.name === "NotSupportedError") {
+      return createDetectorError(
+        detector,
+        "UNSUPPORTED",
+        `${detector} is not supported in this environment.`,
+        error
+      );
+    }
+    if (error.name === "TimeoutError") {
+      return createDetectorError(detector, "TIMEOUT", `${detector} detection timed out.`, error);
+    }
+  }
+  return createDetectorError(detector, "READ_FAILED", `${detector} detection failed.`, error);
+}
+
+// src/detectors/geolocation.ts
+function isGeolocationSupported() {
+  return typeof navigator !== "undefined" && navigator.geolocation !== void 0;
+}
+function getCurrentGeoContext(options = {}) {
+  if (!isGeolocationSupported()) {
+    return Promise.resolve({
+      ok: false,
+      error: createDetectorError(
+        "geolocation",
+        "UNSUPPORTED",
+        "Geolocation is not supported in this environment."
+      )
+    });
+  }
+  if (options.timeout !== void 0 && (!Number.isFinite(options.timeout) || options.timeout < 0)) {
+    return Promise.resolve({
+      ok: false,
+      error: createDetectorError(
+        "geolocation",
+        "INVALID_DATA",
+        "Geolocation timeout must be a non-negative finite number."
+      )
+    });
+  }
+  const positionOptions = {
+    ...options.enableHighAccuracy === void 0 ? {} : { enableHighAccuracy: options.enableHighAccuracy },
+    ...options.timeout === void 0 ? {} : { timeout: options.timeout }
+  };
+  return new Promise((resolve) => {
+    try {
+      navigator.geolocation.getCurrentPosition(
+        (position) => {
+          const currentLatitude = position.coords.latitude;
+          const currentLongitude = position.coords.longitude;
+          if (!Number.isFinite(currentLatitude) || currentLatitude < -90 || currentLatitude > 90 || !Number.isFinite(currentLongitude) || currentLongitude < -180 || currentLongitude > 180) {
+            resolve({
+              ok: false,
+              error: createDetectorError(
+                "geolocation",
+                "INVALID_DATA",
+                "Geolocation returned invalid coordinates."
+              )
+            });
+            return;
+          }
+          resolve({
+            ok: true,
+            value: { type: "geo", currentLatitude, currentLongitude }
+          });
+        },
+        (error) => {
+          const code = error.code === 1 ? "PERMISSION_DENIED" : error.code === 2 ? "POSITION_UNAVAILABLE" : error.code === 3 ? "TIMEOUT" : "READ_FAILED";
+          resolve({
+            ok: false,
+            error: createDetectorError(
+              "geolocation",
+              code,
+              `Geolocation failed: ${error.message || code}.`,
+              error
+            )
+          });
+        },
+        positionOptions
+      );
+    } catch (error) {
+      resolve({
+        ok: false,
+        error: createDetectorError(
+          "geolocation",
+          "READ_FAILED",
+          "Geolocation failed before a position could be requested.",
+          error
+        )
+      });
+    }
+  });
+}
+
+// src/detectors/nfc.ts
+var DEFAULT_TIMEOUT_MS = 3e4;
+function getNdefReaderConstructor() {
+  return globalThis.NDEFReader;
+}
+function isNfcSupported() {
+  return getNdefReaderConstructor() !== void 0;
+}
+function decodeFirstTextRecord(event) {
+  for (const record of event.message.records) {
+    if (record.recordType !== "text" || record.data === void 0) continue;
+    try {
+      const token = new TextDecoder(record.encoding ?? "utf-8").decode(record.data);
+      if (token.length > 0) return token;
+    } catch {
+    }
+  }
+  return null;
+}
+function readNfcContext(options = {}) {
+  const Reader = getNdefReaderConstructor();
+  if (Reader === void 0) {
+    return Promise.resolve({
+      ok: false,
+      error: createDetectorError("nfc", "UNSUPPORTED", "Web NFC is not supported.")
+    });
+  }
+  const timeout = options.timeout ?? DEFAULT_TIMEOUT_MS;
+  if (!Number.isFinite(timeout) || timeout < 0) {
+    return Promise.resolve({
+      ok: false,
+      error: createDetectorError(
+        "nfc",
+        "INVALID_DATA",
+        "NFC timeout must be a non-negative finite number."
+      )
+    });
+  }
+  if (options.signal?.aborted === true) {
+    return Promise.resolve({
+      ok: false,
+      error: createDetectorError("nfc", "ABORTED", "NFC detection was aborted.")
+    });
+  }
+  let reader;
+  try {
+    reader = new Reader();
+  } catch (error) {
+    return Promise.resolve({ ok: false, error: mapBrowserError("nfc", error) });
+  }
+  return new Promise((resolve) => {
+    const scanController = new AbortController();
+    let settled = false;
+    let timer;
+    const finish = (result) => {
+      if (settled) return;
+      settled = true;
+      if (timer !== void 0) clearTimeout(timer);
+      options.signal?.removeEventListener("abort", handleAbort);
+      reader.onreading = null;
+      reader.onreadingerror = null;
+      scanController.abort();
+      resolve(result);
+    };
+    const fail = (error) => finish({ ok: false, error });
+    const handleAbort = () => fail(createDetectorError("nfc", "ABORTED", "NFC detection was aborted."));
+    options.signal?.addEventListener("abort", handleAbort, { once: true });
+    timer = setTimeout(
+      () => fail(createDetectorError("nfc", "TIMEOUT", "NFC detection timed out.")),
+      timeout
+    );
+    reader.onreading = (event) => {
+      const token = decodeFirstTextRecord(event);
+      if (token === null) {
+        fail(createDetectorError("nfc", "NO_TOKEN", "The NFC tag has no text token."));
+        return;
+      }
+      finish({ ok: true, value: { type: "token", token } });
+    };
+    reader.onreadingerror = (event) => fail(createDetectorError("nfc", "READ_FAILED", "The NFC tag could not be read.", event));
+    try {
+      void reader.scan({ signal: scanController.signal }).catch((error) => fail(mapBrowserError("nfc", error)));
+    } catch (error) {
+      fail(mapBrowserError("nfc", error));
+    }
+  });
+}
+
+// src/detectors/passcode.ts
+function normalizePasscode(input, caseSensitive = false) {
+  const normalized = input.normalize("NFKC").trim();
+  return caseSensitive ? normalized : normalized.toUpperCase();
+}
+function verifyPasscode(inputCode, condition) {
+  const input = normalizePasscode(inputCode, condition.caseSensitive);
+  const expected = normalizePasscode(condition.passcode, condition.caseSensitive);
+  return input === expected ? { success: true } : {
+    success: false,
+    reason: "INVALID_PASSCODE",
+    message: "The passcode is invalid."
+  };
+}
+
+// src/detectors/qr.ts
+var DEFAULT_TIMEOUT_MS2 = 3e4;
+var SCAN_INTERVAL_MS = 120;
+function getBarcodeDetectorConstructor() {
+  return globalThis.BarcodeDetector;
+}
+function getMediaDevices() {
+  return typeof navigator === "undefined" ? void 0 : navigator.mediaDevices;
+}
+function isQrSupported() {
+  return getBarcodeDetectorConstructor() !== void 0 && typeof getMediaDevices()?.getUserMedia === "function";
+}
+function createTermination(timeout, signal) {
+  let settle;
+  const promise = new Promise((resolve) => {
+    settle = resolve;
+  });
+  const handleAbort = () => settle?.(createDetectorError("qr", "ABORTED", "QR detection was aborted."));
+  signal?.addEventListener("abort", handleAbort, { once: true });
+  const timer = setTimeout(
+    () => settle?.(createDetectorError("qr", "TIMEOUT", "QR detection timed out.")),
+    timeout
+  );
+  return {
+    promise,
+    cleanup: () => {
+      clearTimeout(timer);
+      signal?.removeEventListener("abort", handleAbort);
+      settle = void 0;
+    }
+  };
+}
+async function raceWithTermination(operation, termination) {
+  return Promise.race([
+    operation.then(
+      (value) => ({ ok: true, value }),
+      (error) => ({ ok: false, error: mapBrowserError("qr", error) })
+    ),
+    termination.then((error) => ({ ok: false, error }))
+  ]);
+}
+function stopStream(stream) {
+  for (const track of stream.getTracks()) track.stop();
+}
+function waitForNextScan() {
+  return new Promise((resolve) => setTimeout(resolve, SCAN_INTERVAL_MS));
+}
+async function readQrContext(videoElement, options = {}) {
+  const Detector = getBarcodeDetectorConstructor();
+  const mediaDevices = getMediaDevices();
+  if (Detector === void 0 || typeof mediaDevices?.getUserMedia !== "function") {
+    return {
+      ok: false,
+      error: createDetectorError(
+        "qr",
+        "UNSUPPORTED",
+        "Live QR detection is not supported in this environment."
+      )
+    };
+  }
+  const timeout = options.timeout ?? DEFAULT_TIMEOUT_MS2;
+  if (!Number.isFinite(timeout) || timeout < 0) {
+    return {
+      ok: false,
+      error: createDetectorError(
+        "qr",
+        "INVALID_DATA",
+        "QR timeout must be a non-negative finite number."
+      )
+    };
+  }
+  if (options.signal?.aborted === true) {
+    return {
+      ok: false,
+      error: createDetectorError("qr", "ABORTED", "QR detection was aborted.")
+    };
+  }
+  const termination = createTermination(timeout, options.signal);
+  let stream = null;
+  try {
+    const mediaPromise = mediaDevices.getUserMedia({
+      audio: false,
+      video: { facingMode: { ideal: options.facingMode ?? "environment" } }
+    });
+    const mediaResult = await raceWithTermination(mediaPromise, termination.promise);
+    if (!mediaResult.ok) {
+      void mediaPromise.then(stopStream, () => void 0);
+      return mediaResult;
+    }
+    stream = mediaResult.value;
+    videoElement.srcObject = stream;
+    videoElement.muted = true;
+    videoElement.playsInline = true;
+    const playResult = await raceWithTermination(videoElement.play(), termination.promise);
+    if (!playResult.ok) return playResult;
+    const detector = new Detector({ formats: ["qr_code"] });
+    while (true) {
+      const detection = await raceWithTermination(
+        detector.detect(videoElement),
+        termination.promise
+      );
+      if (!detection.ok) return detection;
+      const token = detection.value.find((barcode) => barcode.rawValue.length > 0)?.rawValue;
+      if (token !== void 0) {
+        return { ok: true, value: { type: "token", token } };
+      }
+      const interval = await raceWithTermination(waitForNextScan(), termination.promise);
+      if (!interval.ok) return interval;
+    }
+  } catch (error) {
+    return { ok: false, error: mapBrowserError("qr", error) };
+  } finally {
+    termination.cleanup();
+    if (stream !== null) stopStream(stream);
+    try {
+      videoElement.srcObject = null;
+    } catch {
+    }
+  }
+}
+
+// src/engine/transition.ts
+function reconcileRewardStates(rewards, currentStates, acquiredStampCount, now) {
+  const statesById = new Map(currentStates.map((state) => [state.rewardId, state]));
+  return rewards.map((reward) => {
+    const current = statesById.get(reward.id);
+    if (current?.status === "CONSUMED" || current?.status === "EXPIRED") {
+      return current;
+    }
+    if (acquiredStampCount >= reward.requiredStampCount) {
+      if (current?.status === "AVAILABLE") return current;
+      return {
+        rewardId: reward.id,
+        status: "AVAILABLE",
+        unlockedAt: current?.unlockedAt ?? now
+      };
+    }
+    if (current?.status === "LOCKED" && current.unlockedAt === void 0) return current;
+    return { rewardId: reward.id, status: "LOCKED" };
+  });
+}
+function consumeReward(params) {
+  const { reward, currentState } = params;
+  if (currentState.status === "CONSUMED") {
+    return {
+      ok: false,
+      error: { code: "ALREADY_CONSUMED", rewardId: reward.id }
+    };
+  }
+  if (currentState.status !== "AVAILABLE") {
+    return {
+      ok: false,
+      error: { code: "NOT_AVAILABLE", rewardId: reward.id }
+    };
+  }
+  if (reward.redemptionMethod === "staff_passcode") {
+    const passcodeResult = reward.staffPasscode === void 0 ? null : verifyPasscode(params.inputPasscode ?? "", { passcode: reward.staffPasscode });
+    if (passcodeResult === null || !passcodeResult.success) {
+      return {
+        ok: false,
+        error: {
+          code: "INVALID_PASSCODE",
+          rewardId: reward.id,
+          message: passcodeResult?.message ?? "The passcode is invalid."
+        }
+      };
+    }
+  }
+  if (reward.redemptionMethod === "view_only") {
+    return { ok: true, value: currentState };
+  }
+  return {
+    ok: true,
+    value: {
+      ...currentState,
+      status: "CONSUMED",
+      consumedAt: params.now,
+      ...params.staffId === void 0 ? {} : { consumedByStaffId: params.staffId }
+    }
+  };
+}
+function processStamp(state, config, targetStampId, context, now) {
+  const targetStamp = config.stamps.find((stamp) => stamp.id === targetStampId);
+  if (targetStamp === void 0) {
+    return { ok: false, error: { code: "STAMP_NOT_FOUND", stampId: targetStampId } };
+  }
+  const acquiredStampIds = new Set(state.records.map((record2) => record2.stampId));
+  if (acquiredStampIds.has(targetStampId)) {
+    return {
+      ok: false,
+      error: { code: "STAMP_ALREADY_ACQUIRED", stampId: targetStampId }
+    };
+  }
+  if (config.isSequential === true) {
+    const expectedStamp = getOrderedStamps(config).find((stamp) => !acquiredStampIds.has(stamp.id));
+    if (expectedStamp !== void 0 && expectedStamp.id !== targetStampId) {
+      return {
+        ok: false,
+        error: {
+          code: "INVALID_ORDER",
+          stampId: targetStampId,
+          expectedStampId: expectedStamp.id
+        }
+      };
+    }
+  }
+  const conditionResult = evaluateConditionDetailed(targetStamp.condition, context, now);
+  if (!conditionResult.ok) {
+    return {
+      ok: false,
+      error: {
+        code: "CONDITION_MISMATCH",
+        stampId: targetStampId,
+        mismatch: conditionResult.error
+      }
+    };
+  }
+  const record = { stampId: targetStampId, acquiredAt: now };
+  const nextRecords = [...state.records, record];
+  const nextRewards = config.rewards === void 0 && state.rewards === void 0 ? void 0 : reconcileRewardStates(config.rewards ?? [], state.rewards ?? [], nextRecords.length, now);
+  const nextState = {
+    ...state,
+    records: nextRecords,
+    ...nextRewards === void 0 ? {} : { rewards: nextRewards },
+    updatedAt: now
+  };
+  const events = [{ type: "stampAcquired", record }];
+  const completed = config.stamps.length > 0 && config.stamps.every((stamp) => nextState.records.some((item) => item.stampId === stamp.id));
+  if (completed) {
+    events.push({ type: "rallyCompleted", rallyId: config.id, completedAt: now });
+  }
+  return { ok: true, value: { nextState, events } };
+}
+
+// src/client/storage.ts
+var StorageAdapterError = class extends Error {
+  code;
+  operation;
+  rallyId;
+  constructor(code, operation, message, options = {}) {
+    super(message, options.cause === void 0 ? void 0 : { cause: options.cause });
+    this.name = "StorageAdapterError";
+    this.code = code;
+    this.operation = operation;
+    this.rallyId = options.rallyId;
+  }
+};
+function cloneRecord(record) {
+  return record.metadata === void 0 ? { ...record } : { ...record, metadata: { ...record.metadata } };
+}
+function cloneRewardState(state) {
+  return { ...state };
+}
+function cloneState(state) {
+  return {
+    ...state,
+    records: state.records.map(cloneRecord),
+    ...state.rewards === void 0 ? {} : { rewards: state.rewards.map(cloneRewardState) }
+  };
+}
+function isRecord(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const record = value;
+  return typeof record.stampId === "string" && typeof record.acquiredAt === "string" && (record.metadata === void 0 || typeof record.metadata === "object" && record.metadata !== null && !Array.isArray(record.metadata));
+}
+var rewardStatuses = /* @__PURE__ */ new Set(["LOCKED", "AVAILABLE", "CONSUMED", "EXPIRED"]);
+function isOptionalDate(value) {
+  return value === void 0 || typeof value === "string" && !Number.isNaN(Date.parse(value));
+}
+function isRewardState(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const state = value;
+  return typeof state.rewardId === "string" && typeof state.status === "string" && rewardStatuses.has(state.status) && isOptionalDate(state.unlockedAt) && isOptionalDate(state.consumedAt) && (state.consumedByStaffId === void 0 || typeof state.consumedByStaffId === "string");
+}
+function isStampRallyState(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const state = value;
+  return typeof state.rallyId === "string" && typeof state.updatedAt === "string" && Array.isArray(state.records) && state.records.every(isRecord) && (state.rewards === void 0 || Array.isArray(state.rewards) && state.rewards.every(isRewardState));
+}
+function isValidDate(value) {
+  return typeof value === "string" && !Number.isNaN(Date.parse(value));
+}
+function isSnapshotRecord(value) {
+  return isRecord(value) && isValidDate(value.acquiredAt);
+}
+function isRallySnapshot(value) {
+  if (typeof value !== "object" || value === null) return false;
+  const snapshot = value;
+  return snapshot.version === 1 && typeof snapshot.rallyId === "string" && Array.isArray(snapshot.stamps) && snapshot.stamps.every(isSnapshotRecord) && Array.isArray(snapshot.rewards) && snapshot.rewards.every(isRewardState) && isValidDate(snapshot.exportedAt);
+}
+function exportProgressToken(snapshot) {
+  return globalThis.btoa(encodeURIComponent(JSON.stringify(snapshot)));
+}
+function importProgressToken(token, currentRallyId) {
+  try {
+    const parsed = JSON.parse(decodeURIComponent(globalThis.atob(token)));
+    if (!isRallySnapshot(parsed) || parsed.rallyId !== currentRallyId) return null;
+    return {
+      ...parsed,
+      stamps: parsed.stamps.map(cloneRecord),
+      rewards: parsed.rewards.map(cloneRewardState)
+    };
+  } catch {
+    return null;
+  }
+}
+var InMemoryStorage = class {
+  #states = /* @__PURE__ */ new Map();
+  async load(rallyId) {
+    const state = this.#states.get(rallyId);
+    return state === void 0 ? null : cloneState(state);
+  }
+  async save(state) {
+    this.#states.set(state.rallyId, cloneState(state));
+  }
+  async remove(rallyId) {
+    this.#states.delete(rallyId);
+  }
+};
+var defaultStorageWarningHandler = (error) => {
+  console.warn(`[@stamprally/core] ${error.message}`, error);
+};
+var LocalStorageAdapter = class {
+  #providedStorage;
+  #keyPrefix;
+  #failureMode;
+  #onWarning;
+  #fallbackStorage = new InMemoryStorage();
+  #isFallbackActive = false;
+  constructor(options = {}) {
+    this.#providedStorage = options.storage;
+    this.#keyPrefix = options.keyPrefix ?? "stamprally:";
+    this.#failureMode = options.failureMode ?? "fallback";
+    this.#onWarning = options.onWarning ?? defaultStorageWarningHandler;
+  }
+  async load(rallyId) {
+    if (this.#isFallbackActive) return this.#fallbackStorage.load(rallyId);
+    try {
+      const serialized = this.#getStorage("load", rallyId).getItem(this.#key(rallyId));
+      if (serialized === null) return null;
+      let parsed;
+      try {
+        parsed = JSON.parse(serialized);
+      } catch (cause) {
+        throw new StorageAdapterError(
+          "STORAGE_INVALID_DATA",
+          "load",
+          `Stored rally '${rallyId}' is not valid JSON.`,
+          { cause, rallyId }
+        );
+      }
+      if (!isStampRallyState(parsed) || parsed.rallyId !== rallyId) {
+        throw new StorageAdapterError(
+          "STORAGE_INVALID_DATA",
+          "load",
+          `Stored rally '${rallyId}' has an invalid state shape.`,
+          { rallyId }
+        );
+      }
+      return cloneState(parsed);
+    } catch (cause) {
+      return this.#handleFailure(
+        this.#normalizeError(
+          cause,
+          "STORAGE_READ_FAILED",
+          "load",
+          `Failed to read rally '${rallyId}' from localStorage.`,
+          rallyId
+        ),
+        () => this.#fallbackStorage.load(rallyId)
+      );
+    }
+  }
+  async save(state) {
+    if (this.#isFallbackActive) return this.#fallbackStorage.save(state);
+    try {
+      this.#getStorage("save", state.rallyId).setItem(
+        this.#key(state.rallyId),
+        JSON.stringify(state)
+      );
+    } catch (cause) {
+      return this.#handleFailure(
+        this.#normalizeError(
+          cause,
+          "STORAGE_WRITE_FAILED",
+          "save",
+          `Failed to save rally '${state.rallyId}' to localStorage.`,
+          state.rallyId
+        ),
+        () => this.#fallbackStorage.save(state)
+      );
+    }
+  }
+  async remove(rallyId) {
+    if (this.#isFallbackActive) return this.#fallbackStorage.remove(rallyId);
+    try {
+      this.#getStorage("remove", rallyId).removeItem(this.#key(rallyId));
+    } catch (cause) {
+      return this.#handleFailure(
+        this.#normalizeError(
+          cause,
+          "STORAGE_REMOVE_FAILED",
+          "remove",
+          `Failed to remove rally '${rallyId}' from localStorage.`,
+          rallyId
+        ),
+        () => this.#fallbackStorage.remove(rallyId)
+      );
+    }
+  }
+  #key(rallyId) {
+    return `${this.#keyPrefix}${rallyId}`;
+  }
+  #getStorage(operation, rallyId) {
+    if (this.#providedStorage === null) {
+      throw new StorageAdapterError(
+        "STORAGE_UNAVAILABLE",
+        operation,
+        "localStorage is unavailable in this environment.",
+        { rallyId }
+      );
+    }
+    if (this.#providedStorage !== void 0) return this.#providedStorage;
+    if (typeof window === "undefined") {
+      throw new StorageAdapterError(
+        "STORAGE_UNAVAILABLE",
+        operation,
+        "localStorage is unavailable in this environment.",
+        { rallyId }
+      );
+    }
+    try {
+      const storage = window.localStorage;
+      if (storage !== void 0) return storage;
+    } catch (cause) {
+      throw new StorageAdapterError(
+        "STORAGE_UNAVAILABLE",
+        operation,
+        "localStorage is unavailable in this environment.",
+        { cause, rallyId }
+      );
+    }
+    throw new StorageAdapterError(
+      "STORAGE_UNAVAILABLE",
+      operation,
+      "localStorage is unavailable in this environment.",
+      { rallyId }
+    );
+  }
+  #normalizeError(cause, code, operation, message, rallyId) {
+    return cause instanceof StorageAdapterError ? cause : new StorageAdapterError(code, operation, message, { cause, rallyId });
+  }
+  #handleFailure(error, fallback) {
+    if (this.#failureMode === "throw") throw error;
+    this.#isFallbackActive = true;
+    try {
+      this.#onWarning(error);
+    } catch {
+    }
+    return fallback();
+  }
+};
+var INDEXED_DB_STORE_NAME = "states";
+var IndexedDBAdapter = class {
+  #providedFactory;
+  #databaseName;
+  #databasePromise = null;
+  constructor(options = {}) {
+    this.#providedFactory = options.indexedDB;
+    this.#databaseName = options.databaseName ?? "stamprally";
+  }
+  async load(rallyId) {
+    const database = await this.#openDatabase(rallyId);
+    return new Promise((resolve, reject) => {
+      try {
+        const transaction = database.transaction(INDEXED_DB_STORE_NAME, "readonly");
+        const request = transaction.objectStore(INDEXED_DB_STORE_NAME).get(rallyId);
+        request.onsuccess = () => {
+          const value = request.result;
+          if (value === void 0) {
+            resolve(null);
+            return;
+          }
+          if (!isStampRallyState(value) || value.rallyId !== rallyId) {
+            reject(
+              new StorageAdapterError(
+                "STORAGE_INVALID_DATA",
+                "load",
+                `Stored rally '${rallyId}' has an invalid state shape.`,
+                { rallyId }
+              )
+            );
+            return;
+          }
+          resolve(cloneState(value));
+        };
+        request.onerror = () => {
+          reject(
+            new StorageAdapterError(
+              "STORAGE_READ_FAILED",
+              "load",
+              `Failed to read rally '${rallyId}' from IndexedDB.`,
+              { cause: request.error, rallyId }
+            )
+          );
+        };
+      } catch (cause) {
+        reject(
+          new StorageAdapterError(
+            "STORAGE_READ_FAILED",
+            "load",
+            `Failed to read rally '${rallyId}' from IndexedDB.`,
+            { cause, rallyId }
+          )
+        );
+      }
+    });
+  }
+  async save(state) {
+    const database = await this.#openDatabase(state.rallyId);
+    return new Promise((resolve, reject) => {
+      try {
+        const transaction = database.transaction(INDEXED_DB_STORE_NAME, "readwrite");
+        transaction.objectStore(INDEXED_DB_STORE_NAME).put(cloneState(state), state.rallyId);
+        transaction.oncomplete = () => resolve();
+        transaction.onerror = () => {
+          reject(
+            new StorageAdapterError(
+              "STORAGE_WRITE_FAILED",
+              "save",
+              `Failed to save rally '${state.rallyId}' to IndexedDB.`,
+              { cause: transaction.error, rallyId: state.rallyId }
+            )
+          );
+        };
+        transaction.onabort = transaction.onerror;
+      } catch (cause) {
+        reject(
+          new StorageAdapterError(
+            "STORAGE_WRITE_FAILED",
+            "save",
+            `Failed to save rally '${state.rallyId}' to IndexedDB.`,
+            { cause, rallyId: state.rallyId }
+          )
+        );
+      }
+    });
+  }
+  async remove(rallyId) {
+    const database = await this.#openDatabase(rallyId);
+    return new Promise((resolve, reject) => {
+      try {
+        const transaction = database.transaction(INDEXED_DB_STORE_NAME, "readwrite");
+        transaction.objectStore(INDEXED_DB_STORE_NAME).delete(rallyId);
+        transaction.oncomplete = () => resolve();
+        transaction.onerror = () => {
+          reject(
+            new StorageAdapterError(
+              "STORAGE_REMOVE_FAILED",
+              "remove",
+              `Failed to remove rally '${rallyId}' from IndexedDB.`,
+              { cause: transaction.error, rallyId }
+            )
+          );
+        };
+        transaction.onabort = transaction.onerror;
+      } catch (cause) {
+        reject(
+          new StorageAdapterError(
+            "STORAGE_REMOVE_FAILED",
+            "remove",
+            `Failed to remove rally '${rallyId}' from IndexedDB.`,
+            { cause, rallyId }
+          )
+        );
+      }
+    });
+  }
+  #getFactory(rallyId) {
+    if (this.#providedFactory === null) {
+      throw new StorageAdapterError(
+        "STORAGE_UNAVAILABLE",
+        "open",
+        "IndexedDB is unavailable in this environment.",
+        { rallyId }
+      );
+    }
+    if (this.#providedFactory !== void 0) return this.#providedFactory;
+    try {
+      const factory = globalThis.indexedDB;
+      if (factory !== void 0) return factory;
+    } catch (cause) {
+      throw new StorageAdapterError(
+        "STORAGE_UNAVAILABLE",
+        "open",
+        "IndexedDB is unavailable in this environment.",
+        { cause, rallyId }
+      );
+    }
+    throw new StorageAdapterError(
+      "STORAGE_UNAVAILABLE",
+      "open",
+      "IndexedDB is unavailable in this environment.",
+      { rallyId }
+    );
+  }
+  #openDatabase(rallyId) {
+    if (this.#databasePromise !== null) return this.#databasePromise;
+    const factory = this.#getFactory(rallyId);
+    const opening = new Promise((resolve, reject) => {
+      let request;
+      try {
+        request = factory.open(this.#databaseName, 1);
+      } catch (cause) {
+        reject(
+          new StorageAdapterError(
+            "STORAGE_OPEN_FAILED",
+            "open",
+            `Failed to open IndexedDB database '${this.#databaseName}'.`,
+            { cause, rallyId }
+          )
+        );
+        return;
+      }
+      request.onupgradeneeded = () => {
+        const database = request.result;
+        if (!database.objectStoreNames.contains(INDEXED_DB_STORE_NAME)) {
+          database.createObjectStore(INDEXED_DB_STORE_NAME);
+        }
+      };
+      request.onsuccess = () => resolve(request.result);
+      request.onerror = () => {
+        reject(
+          new StorageAdapterError(
+            "STORAGE_OPEN_FAILED",
+            "open",
+            `Failed to open IndexedDB database '${this.#databaseName}'.`,
+            { cause: request.error, rallyId }
+          )
+        );
+      };
+      request.onblocked = () => {
+        reject(
+          new StorageAdapterError(
+            "STORAGE_OPEN_FAILED",
+            "open",
+            `Opening IndexedDB database '${this.#databaseName}' was blocked.`,
+            { rallyId }
+          )
+        );
+      };
+    });
+    this.#databasePromise = opening.catch((error) => {
+      this.#databasePromise = null;
+      throw error;
+    });
+    return this.#databasePromise;
+  }
+};
+
+// src/client/client.ts
+var systemClock = () => (/* @__PURE__ */ new Date()).toISOString();
+var StampRallyClient = class {
+  #listeners = /* @__PURE__ */ new Set();
+  #config;
+  #storage;
+  #clock;
+  #currentState = null;
+  #initialization = null;
+  #operationQueue = Promise.resolve();
+  constructor(config, storage, clock = systemClock) {
+    this.#config = config;
+    this.#storage = storage;
+    this.#clock = clock;
+  }
+  getState() {
+    return this.#currentState;
+  }
+  getConfig() {
+    return this.#config;
+  }
+  subscribe(listener) {
+    this.#listeners.add(listener);
+    return () => {
+      this.#listeners.delete(listener);
+    };
+  }
+  init() {
+    return this.initialize();
+  }
+  initialize() {
+    if (this.#currentState !== null) {
+      return Promise.resolve(this.#currentState);
+    }
+    if (this.#initialization === null) {
+      this.#initialization = this.#storage.load(this.#config.id).then((storedState) => {
+        const state = storedState === null ? this.#createEmptyState(this.#clock()) : this.#reconcileState(cloneState(storedState), storedState.updatedAt);
+        this.#currentState = state;
+        this.#emit(state);
+        return state;
+      }).catch((error) => {
+        this.#initialization = null;
+        throw error;
+      });
+    }
+    return this.#initialization;
+  }
+  acquire(stampId, context, now = this.#clock()) {
+    return this.#enqueue(async () => {
+      const currentState = await this.initialize();
+      const result = processStamp(currentState, this.#config, stampId, context, now);
+      if (!result.ok) {
+        return result;
+      }
+      await this.#storage.save(result.value.nextState);
+      this.#currentState = result.value.nextState;
+      this.#emit(result.value.nextState);
+      return result;
+    });
+  }
+  reset(now = this.#clock()) {
+    return this.#enqueue(async () => {
+      const initialization = this.#initialization;
+      if (initialization !== null) {
+        await initialization.catch(() => void 0);
+      }
+      await this.#storage.remove(this.#config.id);
+      const nextState = this.#createEmptyState(now);
+      this.#currentState = nextState;
+      this.#initialization = Promise.resolve(nextState);
+      this.#emit(nextState);
+      return nextState;
+    });
+  }
+  restore(state) {
+    return this.#enqueue(async () => {
+      const initialization = this.#initialization;
+      if (initialization !== null) {
+        await initialization.catch(() => void 0);
+      }
+      if (state.rallyId !== this.#config.id) {
+        throw new Error(
+          `Cannot restore rally '${state.rallyId}' into client '${this.#config.id}'.`
+        );
+      }
+      const nextState = this.#reconcileState(cloneState(state), state.updatedAt);
+      await this.#storage.save(nextState);
+      this.#currentState = nextState;
+      this.#initialization = Promise.resolve(nextState);
+      this.#emit(nextState);
+      return nextState;
+    });
+  }
+  #enqueue(operation) {
+    const next = this.#operationQueue.then(operation, operation);
+    this.#operationQueue = next.then(
+      () => void 0,
+      () => void 0
+    );
+    return next;
+  }
+  #emit(state) {
+    for (const listener of this.#listeners) {
+      listener(state);
+    }
+  }
+  #createEmptyState(now) {
+    const state = {
+      rallyId: this.#config.id,
+      records: [],
+      ...this.#config.rewards === void 0 ? {} : {
+        rewards: reconcileRewardStates(this.#config.rewards, [], 0, now)
+      },
+      updatedAt: now
+    };
+    return state;
+  }
+  #reconcileState(state, now) {
+    const configuredStampIds = new Set(this.#config.stamps.map((stamp) => stamp.id));
+    const seenStampIds = /* @__PURE__ */ new Set();
+    const records = state.records.filter((record) => {
+      if (!configuredStampIds.has(record.stampId) || seenStampIds.has(record.stampId)) return false;
+      seenStampIds.add(record.stampId);
+      return true;
+    });
+    if (this.#config.rewards === void 0 && state.rewards === void 0) {
+      return records.length === state.records.length ? state : { ...state, records };
+    }
+    return {
+      ...state,
+      records,
+      rewards: reconcileRewardStates(
+        this.#config.rewards ?? [],
+        state.rewards ?? [],
+        records.length,
+        now
+      )
+    };
+  }
+};
+
+// src/domain/i18n.ts
+function resolveLocalizedText(text, locale, fallbackLocale = "ja") {
+  if (text === void 0 || text === "") return "";
+  if (typeof text === "string") return text;
+  return text[locale] || text[fallbackLocale] || "";
+}
+function toLocalizedString(text) {
+  if (text === void 0) return { ja: "", en: "" };
+  return typeof text === "string" ? { ja: text, en: "" } : { ...text };
+}
+
+// src/domain/models.ts
+var DEFAULT_SHEET_THEME = {
+  primaryColor: "#9e551e",
+  backgroundColor: "#fbf4df",
+  cardBackgroundColor: "#fffdf5",
+  textColor: "#352f25",
+  slotShape: "rounded",
+  gridColumns: 3,
+  unclaimedOpacity: 1,
+  fontFamily: "serif"
+};
+
+// src/domain/themePresets.ts
+var THEME_PRESETS = [
+  {
+    id: "default",
+    name: { ja: "\u30AF\u30E9\u30B7\u30C3\u30AF\u30D6\u30EB\u30FC", en: "Classic Blue" },
+    description: {
+      ja: "\u9752\u3092\u57FA\u8ABF\u306B\u3057\u305F\u3001\u660E\u308B\u304F\u89AA\u3057\u307F\u3084\u3059\u3044\u5B9A\u756A\u30C7\u30B6\u30A4\u30F3\u3067\u3059\u3002",
+      en: "A bright, approachable classic built around a crisp blue palette."
+    },
+    theme: {
+      primaryColor: "#2563eb",
+      backgroundColor: "#eff6ff",
+      cardBackgroundColor: "#ffffff",
+      textColor: "#1e293b",
+      slotShape: "circle",
+      gridColumns: 3,
+      unclaimedOpacity: 1,
+      completedStampColor: "#dc2626",
+      fontFamily: "serif"
+    }
+  },
+  {
+    id: "modern_dark",
+    name: { ja: "\u30E2\u30C0\u30F3\u30C0\u30FC\u30AF", en: "Modern Dark" },
+    description: {
+      ja: "\u6DF1\u3044\u30CD\u30A4\u30D3\u30FC\u3068\u30A8\u30E1\u30E9\u30EB\u30C9\u3067\u307E\u3068\u3081\u305F\u3001\u6D17\u7DF4\u3055\u308C\u305F\u30C0\u30FC\u30AF\u30C6\u30FC\u30DE\u3067\u3059\u3002",
+      en: "A polished dark theme pairing deep navy with emerald accents."
+    },
+    theme: {
+      primaryColor: "#10b981",
+      backgroundColor: "#0f172a",
+      cardBackgroundColor: "#1e293b",
+      textColor: "#f8fafc",
+      slotShape: "rounded",
+      gridColumns: 3,
+      unclaimedOpacity: 1,
+      completedStampColor: "#34d399",
+      fontFamily: "system-ui"
+    }
+  },
+  {
+    id: "pop_candy",
+    name: { ja: "\u30DD\u30C3\u30D7\u30AD\u30E3\u30F3\u30C7\u30A3", en: "Pop Candy" },
+    description: {
+      ja: "\u30D4\u30F3\u30AF\u3092\u4E3B\u5F79\u306B\u3057\u305F\u3001\u697D\u3057\u304F\u83EF\u3084\u304B\u306A\u30AD\u30E3\u30F3\u30C7\u30A3\u30AB\u30E9\u30FC\u30C6\u30FC\u30DE\u3067\u3059\u3002",
+      en: "A playful candy-colored theme with vivid pink at center stage."
+    },
+    theme: {
+      primaryColor: "#ec4899",
+      backgroundColor: "#fdf2f8",
+      cardBackgroundColor: "#ffffff",
+      textColor: "#831843",
+      slotShape: "circle",
+      gridColumns: 2,
+      unclaimedOpacity: 1,
+      completedStampColor: "#f43f5e",
+      fontFamily: "rounded-sans"
+    }
+  },
+  {
+    id: "retro_craft",
+    name: { ja: "\u30EC\u30C8\u30ED\u30AF\u30E9\u30D5\u30C8", en: "Retro Craft" },
+    description: {
+      ja: "\u30AF\u30E9\u30D5\u30C8\u7D19\u3068\u8D64\u8336\u8272\u306E\u30A4\u30F3\u30AF\u3092\u601D\u308F\u305B\u308B\u3001\u6E29\u304B\u307F\u306E\u3042\u308B\u30EC\u30C8\u30ED\u30C6\u30FC\u30DE\u3067\u3059\u3002",
+      en: "A warm retro theme inspired by craft paper and earthy red ink."
+    },
+    theme: {
+      primaryColor: "#9a3412",
+      backgroundColor: "#fef3c7",
+      cardBackgroundColor: "#fffbeb",
+      textColor: "#78350f",
+      slotShape: "square",
+      gridColumns: 3,
+      unclaimedOpacity: 1,
+      completedStampColor: "#b91c1c",
+      fontFamily: "handwritten"
+    }
+  },
+  {
+    id: "cyber",
+    name: { ja: "\u30B5\u30A4\u30D0\u30FC\u30CD\u30AA\u30F3", en: "Cyber Neon" },
+    description: {
+      ja: "\u30B7\u30A2\u30F3\u3068\u7D2B\u306E\u30CD\u30AA\u30F3\u304C\u6620\u3048\u308B\u3001\u30B7\u30E3\u30FC\u30D7\u306A\u8FD1\u672A\u6765\u30C6\u30FC\u30DE\u3067\u3059\u3002",
+      en: "A sharp futuristic theme illuminated by cyan and violet neon."
+    },
+    theme: {
+      primaryColor: "#06b6d4",
+      backgroundColor: "#09090b",
+      cardBackgroundColor: "#18181b",
+      textColor: "#fafafa",
+      slotShape: "square",
+      gridColumns: 4,
+      unclaimedOpacity: 1,
+      completedStampColor: "#a855f7",
+      fontFamily: "monospace"
+    }
+  }
+];
+
+exports.DEFAULT_SHEET_THEME = DEFAULT_SHEET_THEME;
+exports.InMemoryStorage = InMemoryStorage;
+exports.IndexedDBAdapter = IndexedDBAdapter;
+exports.LocalStorageAdapter = LocalStorageAdapter;
+exports.StampRallyClient = StampRallyClient;
+exports.StorageAdapterError = StorageAdapterError;
+exports.THEME_PRESETS = THEME_PRESETS;
+exports.calculateDistanceMeters = calculateDistanceMeters;
+exports.calculateProgress = calculateProgress;
+exports.consumeReward = consumeReward;
+exports.evaluateCondition = evaluateCondition;
+exports.evaluateConditionDetailed = evaluateConditionDetailed;
+exports.exportProgressToken = exportProgressToken;
+exports.getCurrentGeoContext = getCurrentGeoContext;
+exports.importProgressToken = importProgressToken;
+exports.isGeolocationSupported = isGeolocationSupported;
+exports.isNfcSupported = isNfcSupported;
+exports.isQrSupported = isQrSupported;
+exports.isRewardState = isRewardState;
+exports.isStampRallyState = isStampRallyState;
+exports.normalizePasscode = normalizePasscode;
+exports.processStamp = processStamp;
+exports.readNfcContext = readNfcContext;
+exports.readQrContext = readQrContext;
+exports.reconcileRewardStates = reconcileRewardStates;
+exports.resolveLocalizedText = resolveLocalizedText;
+exports.toLocalizedString = toLocalizedString;
+exports.verifyPasscode = verifyPasscode;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map