@relaybus/core 0.2.0 → 0.3.1

package/dist/internal/index.cjs

@@ -0,0 +1,662 @@
+'use strict';
+
+var chunkJ76M7XTS_cjs = require('../chunk-J76M7XTS.cjs');
+
+// src/internal/validation.ts
+function assertPositiveInteger(value, name) {
+  return chunkJ76M7XTS_cjs.PositiveInteger.of(value, name);
+}
+
+// src/internal/field-extractors.ts
+function fromHeader(name) {
+  if (name.length === 0) {
+    throw new chunkJ76M7XTS_cjs.ConfigurationError("fromHeader needs a header name");
+  }
+  return (message) => Object.hasOwn(message.headers, name) ? message.headers[name] : void 0;
+}
+function fromPayloadField(path) {
+  const segments = path.split(".");
+  if (segments.some((segment) => segment.length === 0)) {
+    throw new chunkJ76M7XTS_cjs.ConfigurationError(
+      `fromPayloadField needs a dotted path of non-empty names, received '${path}'`
+    );
+  }
+  return (message) => {
+    let value = message.payload;
+    for (const segment of segments) {
+      if (typeof value !== "object" || value === null || !Object.hasOwn(value, segment)) {
+        return void 0;
+      }
+      value = value[segment];
+    }
+    if (typeof value === "string") {
+      return value;
+    }
+    return Number.isSafeInteger(value) ? String(value) : void 0;
+  };
+}
+
+// src/internal/cloudevents.ts
+function mediaTypeOf(contentType) {
+  return typeof contentType === "string" ? contentType.split(";")[0].trim().toLowerCase() : void 0;
+}
+function isJsonObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function createCloudEventReaders(invalid) {
+  const optionalAttribute = (body, name) => {
+    const value = body[name];
+    if (value !== void 0 && typeof value !== "string") {
+      throw invalid(`Attribute '${name}' must be a string`);
+    }
+    return value;
+  };
+  return {
+    optionalAttribute,
+    requiredAttribute: (body, name) => {
+      const value = optionalAttribute(body, name);
+      if (value === void 0 || value.length === 0) {
+        throw invalid(`Attribute '${name}' is missing or empty`);
+      }
+      return value;
+    },
+    assertValidType: (type, label) => {
+      try {
+        chunkJ76M7XTS_cjs.assertEventType(type);
+      } catch (error) {
+        throw invalid(`${label} is not a valid event type: ${error.message}`);
+      }
+    },
+    assertJsonDataContentType: (dataContentType) => {
+      const mediaType = mediaTypeOf(dataContentType);
+      if (mediaType !== void 0 && mediaType !== "application/json" && mediaType !== "text/json" && !mediaType.endsWith("+json")) {
+        throw invalid(`datacontenttype must be JSON, received '${dataContentType}'`);
+      }
+    }
+  };
+}
+function writeStructuredCloudEvent(envelope, { time, data }) {
+  const attributes = {
+    specversion: "1.0",
+    id: envelope.id,
+    type: envelope.type,
+    source: envelope.source,
+    time,
+    datacontenttype: "application/json",
+    ...envelope.key === null ? {} : { subject: envelope.key },
+    ...envelope.correlationId === null ? {} : { correlationid: envelope.correlationId },
+    ...envelope.causationId === null ? {} : { causationid: envelope.causationId }
+  };
+  return `${JSON.stringify(attributes).slice(0, -1)},"data":${data}}`;
+}
+
+// src/internal/json-envelope-plan.ts
+var OPTIONAL_NAMES = [
+  "key",
+  "source",
+  "occurredAt",
+  "correlationId",
+  "causationId"
+];
+var ARRAY_INDEX = /^(?:0|[1-9]\d*)$/;
+function compile(mapping, transportIds) {
+  if (!isJsonObject(mapping)) {
+    throw new chunkJ76M7XTS_cjs.ConfigurationError("jsonEnvelope needs a mapping object");
+  }
+  const optional = {};
+  for (const name of OPTIONAL_NAMES) {
+    const field = mapping[name];
+    if (field !== void 0) {
+      optional[name] = toLocation(field, name);
+    }
+  }
+  const plan = {
+    type: compileType(mapping.type),
+    id: compileId(mapping.id, transportIds),
+    optional,
+    payload: compilePayload(mapping.payload),
+    headers: compileHeaders(mapping.headers),
+    mappedHeaders: /* @__PURE__ */ new Set()
+  };
+  return assertDisjoint(plan);
+}
+function compileType(type) {
+  if (isJsonObject(type) && typeof type["fixed"] === "string") {
+    chunkJ76M7XTS_cjs.assertEventType(type["fixed"]);
+    return { fixed: type["fixed"] };
+  }
+  if (type === void 0) {
+    throw new chunkJ76M7XTS_cjs.ConfigurationError("jsonEnvelope needs a type: { body }, { header } or { fixed }");
+  }
+  return toLocation(type, "type");
+}
+function compileId(id, transportIds) {
+  if (typeof id === "string" && transportIds.includes(id)) {
+    return void 0;
+  }
+  if (!isJsonObject(id)) {
+    throw new chunkJ76M7XTS_cjs.ConfigurationError(
+      `jsonEnvelope needs an id: { body }, { header } or one of ${transportIds.map((name) => `'${name}'`).join(", ")}`
+    );
+  }
+  return toLocation(id, "id");
+}
+function compilePayload(payload) {
+  if (payload === "whole-body") {
+    return void 0;
+  }
+  if (!isJsonObject(payload) || typeof payload["body"] !== "string") {
+    throw new chunkJ76M7XTS_cjs.ConfigurationError(
+      "jsonEnvelope needs a payload: { body: '<path>' } or 'whole-body'"
+    );
+  }
+  return toPath(payload["body"], "payload");
+}
+function compileHeaders(headers) {
+  if (headers === void 0 || headers === "message-headers") {
+    return void 0;
+  }
+  if (!isJsonObject(headers) || typeof headers["body"] !== "string") {
+    throw new chunkJ76M7XTS_cjs.ConfigurationError(
+      "jsonEnvelope headers must be { body: '<path>' } or 'message-headers'"
+    );
+  }
+  return toPath(headers["body"], "headers");
+}
+function toLocation(field, label) {
+  if (isJsonObject(field) && typeof field["header"] === "string" && field["header"].length > 0) {
+    return { label, header: field["header"] };
+  }
+  if (isJsonObject(field) && typeof field["body"] === "string") {
+    return { label, path: toPath(field["body"], label) };
+  }
+  throw new chunkJ76M7XTS_cjs.ConfigurationError(
+    `jsonEnvelope ${label} must be { body: '<path>' } or { header: '<name>' }`
+  );
+}
+function toPath(path, label) {
+  const segments = path.split(".");
+  if (segments.some((segment) => segment.length === 0)) {
+    throw new chunkJ76M7XTS_cjs.ConfigurationError(
+      `jsonEnvelope ${label} needs a dotted path of non-empty names, received '${path}'`
+    );
+  }
+  return segments;
+}
+function assertDisjoint(plan) {
+  const locations = [plan.type, plan.id, ...Object.values(plan.optional)].filter(
+    (location) => location !== void 0 && !("fixed" in location)
+  );
+  const headers = locations.flatMap((location) => "header" in location ? [location.header] : []);
+  const duplicate = headers.find((name, index) => headers.indexOf(name) !== index);
+  if (duplicate !== void 0) {
+    throw new chunkJ76M7XTS_cjs.ConfigurationError(`jsonEnvelope maps header '${duplicate}' twice`);
+  }
+  const paths = [
+    ...locations.flatMap((location) => "path" in location ? [location.path] : []),
+    ...[plan.payload, plan.headers].filter((path) => path !== void 0)
+  ];
+  assertNoNestedPaths(paths);
+  return { ...plan, mappedHeaders: new Set(headers) };
+}
+function assertNoNestedPaths(paths) {
+  paths.forEach((path, index) => {
+    for (const other of paths.slice(index + 1)) {
+      assertCompatiblePaths(path, other);
+    }
+  });
+}
+function assertCompatiblePaths(path, other) {
+  const parting = path.findIndex((segment, position) => segment !== other[position]);
+  const both = `'${path.join(".")}' and '${other.join(".")}'`;
+  if (parting === -1 || parting === other.length) {
+    throw new chunkJ76M7XTS_cjs.ConfigurationError(`jsonEnvelope body paths ${both} overlap`);
+  }
+  if (ARRAY_INDEX.test(path[parting]) !== ARRAY_INDEX.test(other[parting])) {
+    throw new chunkJ76M7XTS_cjs.ConfigurationError(`jsonEnvelope body paths ${both} mix an array index and a name`);
+  }
+}
+
+// src/internal/json-envelope-read.ts
+var RFC3339_PATTERN = /^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}(?:\.\d+)?(?:Z|[+-]\d{2}:\d{2})$/i;
+function readMessage(message, context) {
+  const { plan, failures } = context;
+  if (plan.payload !== void 0 && !isJsonObject(message.body)) {
+    throw failures.invalid("The message body must be a JSON object");
+  }
+  const read = (location) => location === void 0 ? void 0 : readText(message, { location, failures });
+  const fields = {
+    id: plan.id === void 0 ? void 0 : requireText(read(plan.id), { location: plan.id, failures }),
+    type: readType(message, context),
+    payload: readPayload(message.body, context),
+    key: read(plan.optional.key),
+    source: read(plan.optional.source),
+    headers: readEventHeaders(message, plan),
+    correlationId: read(plan.optional.correlationId) ?? null,
+    causationId: read(plan.optional.causationId) ?? null,
+    occurredAt: readTime(read(plan.optional.occurredAt), failures)
+  };
+  return Object.fromEntries(
+    Object.entries(fields).filter((entry) => entry[1] !== void 0)
+  );
+}
+function readType(message, { plan, failures }) {
+  if ("fixed" in plan.type) {
+    return plan.type.fixed;
+  }
+  const location = plan.type;
+  const type = requireText(readText(message, { location, failures }), { location, failures });
+  try {
+    chunkJ76M7XTS_cjs.assertEventType(type);
+  } catch (error) {
+    throw failures.invalid(`The event type is not a valid event type: ${error.message}`);
+  }
+  return type;
+}
+function readPayload(body, { plan, failures }) {
+  if (plan.payload === void 0) {
+    return body;
+  }
+  const payload = valueAt(body, plan.payload);
+  if (payload === void 0) {
+    throw failures.invalid(`The message has no payload at '${plan.payload.join(".")}'`);
+  }
+  return payload;
+}
+function readEventHeaders(message, plan) {
+  if (plan.headers === void 0) {
+    return Object.fromEntries(
+      Object.entries(message.headers).filter(([name]) => !plan.mappedHeaders.has(name))
+    );
+  }
+  const headers = valueAt(message.body, plan.headers);
+  return isJsonObject(headers) ? Object.fromEntries(
+    Object.entries(headers).filter(
+      (entry) => typeof entry[1] === "string"
+    )
+  ) : {};
+}
+function readTime(text, failures) {
+  if (text === void 0) {
+    return void 0;
+  }
+  const time = new Date(text);
+  if (!RFC3339_PATTERN.test(text) || Number.isNaN(time.getTime())) {
+    throw failures.invalid(`The event time is not an RFC 3339 timestamp: '${text}'`);
+  }
+  return time;
+}
+function readText(message, { location, failures }) {
+  const value = "header" in location ? Object.hasOwn(message.headers, location.header) ? message.headers[location.header] : void 0 : valueAt(message.body, location.path);
+  if (value === void 0 || value === null || value === "") {
+    return void 0;
+  }
+  if (typeof value === "string") {
+    return value;
+  }
+  if (typeof value === "number" && Number.isSafeInteger(value)) {
+    return String(value);
+  }
+  throw failures.invalid(`The ${location.label} at ${describe(location)} must be a string`);
+}
+function requireText(value, { location, failures }) {
+  if (value === void 0) {
+    throw failures.invalid(`The message has no ${location.label} at ${describe(location)}`);
+  }
+  return value;
+}
+function describe(location) {
+  return "header" in location ? `header '${location.header}'` : `'${location.path.join(".")}'`;
+}
+function valueAt(body, path) {
+  let value = body;
+  for (const segment of path) {
+    if (typeof value !== "object" || value === null || !Object.hasOwn(value, segment)) {
+      return void 0;
+    }
+    value = value[segment];
+  }
+  return value;
+}
+
+// src/internal/json-envelope-write.ts
+var MAXIMUM_RFC3339_YEAR = 9999;
+function writeMessage(envelope, { plan, failures }) {
+  const root = {};
+  const headers = [];
+  const put = (location, value) => {
+    if ("header" in location) {
+      headers.push([location.header, value]);
+    } else {
+      setAt(root, { path: location.path, value });
+    }
+  };
+  if ("fixed" in plan.type) {
+    if (envelope.type !== plan.type.fixed) {
+      throw failures.unencodable(
+        `Event ${envelope.id} has type '${envelope.type}', but this route carries only '${plan.type.fixed}'`
+      );
+    }
+  } else {
+    put(plan.type, envelope.type);
+  }
+  if (plan.id !== void 0) {
+    put(plan.id, envelope.id);
+  }
+  for (const [name, value] of optionalValues(envelope, failures)) {
+    const location = plan.optional[name];
+    if (location !== void 0 && value !== null) {
+      put(location, value);
+    }
+  }
+  return {
+    body: writeBody(envelope, { plan, root }),
+    headers: Object.fromEntries([...eventHeaderEntries(envelope, { plan, failures }), ...headers])
+  };
+}
+function optionalValues(envelope, failures) {
+  return [
+    ["key", envelope.key],
+    ["source", envelope.source],
+    ["occurredAt", formatTime(envelope, failures)],
+    ["correlationId", envelope.correlationId],
+    ["causationId", envelope.causationId]
+  ];
+}
+function writeBody(envelope, { plan, root }) {
+  if (plan.payload === void 0) {
+    return envelope.payload;
+  }
+  setAt(root, { path: plan.payload, value: envelope.payload });
+  if (plan.headers !== void 0) {
+    setAt(root, {
+      path: plan.headers,
+      value: Object.fromEntries(Object.entries(envelope.headers))
+    });
+  }
+  return root;
+}
+function eventHeaderEntries(envelope, { plan, failures }) {
+  if (plan.headers !== void 0) {
+    return [];
+  }
+  const entries = Object.entries(envelope.headers);
+  const taken = entries.find(([name]) => plan.mappedHeaders.has(name));
+  if (taken !== void 0) {
+    throw failures.unencodable(
+      `Event ${envelope.id} has a header '${taken[0]}', which the mapping uses for another field`
+    );
+  }
+  return entries;
+}
+function formatTime(envelope, failures) {
+  const year = envelope.occurredAt.getUTCFullYear();
+  if (Number.isNaN(year) || year < 0 || year > MAXIMUM_RFC3339_YEAR) {
+    throw failures.unencodable(
+      `Event ${envelope.id} has an occurredAt that is not an RFC 3339 instant (invalid date or year outside 0..9999)`
+    );
+  }
+  return envelope.occurredAt.toISOString();
+}
+function setAt(root, { path, value }) {
+  let container = root;
+  for (const [index, segment] of path.slice(0, -1).entries()) {
+    if (!Object.hasOwn(container, segment)) {
+      defineValue(container, {
+        name: segment,
+        value: ARRAY_INDEX.test(path[index + 1]) ? [] : {}
+      });
+    }
+    container = container[segment];
+  }
+  defineValue(container, { name: path.at(-1), value });
+}
+function defineValue(target, { name, value }) {
+  Object.defineProperty(target, name, {
+    value,
+    enumerable: true,
+    writable: true,
+    configurable: true
+  });
+}
+
+// src/internal/json-envelope.ts
+function createJsonEnvelopeFormat(mapping, {
+  transportIds,
+  failures
+}) {
+  const plan = compile(mapping, transportIds);
+  return {
+    write: (envelope) => writeMessage(envelope, { plan, failures }),
+    read: (message) => readMessage(message, { plan, failures })
+  };
+}
+
+// src/store-kit/handed-out-ledger.ts
+var HandedOutLedger = class {
+  #entries = /* @__PURE__ */ new Map();
+  register(lease, entry) {
+    this.#entries.set(chunkJ76M7XTS_cjs.DeliveryLeaseIdentity.of(lease.deliveryId, lease.leaseToken), entry);
+  }
+  /** Whether the claim with this identity ({@link DeliveryLeaseIdentity.of}) is handed out. */
+  has(identity) {
+    return this.#entries.has(identity);
+  }
+  forget(lease) {
+    this.#entries.delete(chunkJ76M7XTS_cjs.DeliveryLeaseIdentity.of(lease.deliveryId, lease.leaseToken));
+  }
+  /** Forgets every entry `settled` says is settled. */
+  forgetWhere(settled) {
+    for (const [identity, entry] of this.#entries) {
+      if (settled(entry, identity)) {
+        this.#entries.delete(identity);
+      }
+    }
+  }
+  /** The entries handed out to `owner`. */
+  entriesOf(owner) {
+    return [...this.#entries.values()].filter((entry) => entry.owner === owner);
+  }
+};
+
+// src/store-kit/owner-serialized-claims.ts
+var OwnerSerializedClaims = class {
+  /** The last claim of each owner still running; the next one waits for it. */
+  #queues = /* @__PURE__ */ new Map();
+  claim(request) {
+    if (this.claimsNothing(request)) {
+      return Promise.resolve([]);
+    }
+    return this.#serialized(request.leaseOwner, () => this.claimInTurn(request));
+  }
+  /** Whether the request cannot claim anything: no handlers, or a limit that is not above 0. */
+  claimsNothing(request) {
+    return request.handlers.length === 0 || !(request.limit > 0);
+  }
+  #serialized(owner, work) {
+    const previous = this.#queues.get(owner) ?? Promise.resolve();
+    const run = previous.then(work, work);
+    const tail = run.then(
+      () => void 0,
+      () => void 0
+    );
+    this.#queues.set(owner, tail);
+    void tail.then(() => {
+      if (this.#queues.get(owner) === tail) {
+        this.#queues.delete(owner);
+      }
+    });
+    return run;
+  }
+};
+
+// src/transport-kit/decoded-event-reader.ts
+function observeRejection(value) {
+  if (typeof value === "object" && value !== null && "then" in value) {
+    Promise.resolve(value).catch(() => void 0);
+  }
+}
+var DecodedEventReader = class {
+  /**
+   * Fills the fields a decoder left out and guards against a decoder that returned no object,
+   * which would otherwise surface as a retried `TypeError` instead of a malformed message.
+   */
+  complete(decoded, message) {
+    if (typeof decoded !== "object" || decoded === null) {
+      throw this.invalid("The decoder must return an event object synchronously");
+    }
+    if ("then" in decoded) {
+      observeRejection(decoded);
+      throw this.invalid("The decoder must return an event object synchronously");
+    }
+    const event = decoded;
+    return {
+      id: event.id,
+      type: event.type,
+      source: event.source ?? this.defaultSource(message),
+      key: event.key === void 0 ? this.defaultKey(message) : event.key,
+      payload: event.payload,
+      headers: event.headers ?? {},
+      correlationId: event.correlationId ?? null,
+      causationId: event.causationId ?? null,
+      occurredAt: event.occurredAt ?? this.defaultTime(message)
+    };
+  }
+  /** The text an option gives for `plain`; undefined when it gives none or `''`. */
+  text(option, { plain, name }) {
+    const value = typeof option === "function" ? option(plain) : option;
+    if (value === void 0 || value === null) {
+      return void 0;
+    }
+    if (typeof value !== "string") {
+      observeRejection(value);
+      throw this.invalid(`The ${name} option returned ${typeof value}, expected a string`);
+    }
+    return value.length === 0 ? void 0 : value;
+  }
+};
+
+// src/transport-kit/subscribing-transport.ts
+var SubscribingTransport = class {
+  /**
+   * Subscribes to `destinations`. Not async itself: the subscription's own promise is returned
+   * as it is, so its checks reject rather than throw.
+   */
+  // eslint-disable-next-line relaybus/max-two-params -- the Transport.subscribe signature
+  subscribe(destinations, onMessage, hooks) {
+    return this.openSubscription({ destinations, onMessage, hooks });
+  }
+};
+
+// src/values/bounded-integer.ts
+var BoundedInteger = class {
+  /** Returns `value` when it is an integer within the bounds, else throws a {@link ConfigurationError}. */
+  static of(value, { name, minimum, maximum }) {
+    if (!Number.isInteger(value) || value < minimum || value > maximum) {
+      throw new chunkJ76M7XTS_cjs.ConfigurationError(
+        `${name} must be an integer from ${minimum} to ${maximum}, received ${value}`
+      );
+    }
+    return value;
+  }
+};
+
+// src/values/exponential-backoff.ts
+var ExponentialBackoff = class {
+  initialMs;
+  maxMs;
+  constructor({ initialMs, maxMs }) {
+    this.initialMs = initialMs;
+    this.maxMs = maxMs;
+  }
+  /** The delay after failed attempt `attempt` (1-based). */
+  delayFor(attempt) {
+    return Math.min(this.initialMs * 2 ** (attempt - 1), this.maxMs);
+  }
+};
+
+// src/values/lane-lease-token.ts
+var LANE_DIGITS = 3;
+var LaneLeaseTokenFormat = class {
+  #pattern;
+  #laneCount;
+  constructor(limits) {
+    this.#laneCount = limits.laneCount;
+    this.#pattern = new RegExp(
+      `^(\\d{1,${LANE_DIGITS}}):(\\d{1,${limits.epochDigits}}):(\\d{1,${limits.claimsDigits}})$`
+    );
+  }
+  format(lane, { epoch, claims }) {
+    return `${lane}:${epoch}:${claims}`;
+  }
+  /** The parts of `token`; undefined when the store cannot have issued it. */
+  parse(token) {
+    const match = this.#pattern.exec(token);
+    if (match === null || Number(match[1]) >= this.#laneCount) {
+      return void 0;
+    }
+    return { lane: Number(match[1]), epoch: match[2], claims: Number(match[3]) };
+  }
+};
+
+// src/values/non-empty-text.ts
+var NonEmptyText = class _NonEmptyText {
+  static of(value, name) {
+    if (value.length === 0) {
+      throw new chunkJ76M7XTS_cjs.ConfigurationError(`${name} must not be empty`);
+    }
+    return value;
+  }
+  /** Like {@link NonEmptyText.of}, for an option that may be left out. */
+  static optional(value, name) {
+    return value === void 0 ? void 0 : _NonEmptyText.of(value, name);
+  }
+};
+
+Object.defineProperty(exports, "CompositeKey", {
+  enumerable: true,
+  get: function () { return chunkJ76M7XTS_cjs.CompositeKey; }
+});
+Object.defineProperty(exports, "DeliveryLeaseIdentity", {
+  enumerable: true,
+  get: function () { return chunkJ76M7XTS_cjs.DeliveryLeaseIdentity; }
+});
+Object.defineProperty(exports, "LeaseSettlement", {
+  enumerable: true,
+  get: function () { return chunkJ76M7XTS_cjs.LeaseSettlement; }
+});
+Object.defineProperty(exports, "Milliseconds", {
+  enumerable: true,
+  get: function () { return chunkJ76M7XTS_cjs.Milliseconds; }
+});
+Object.defineProperty(exports, "PositiveInteger", {
+  enumerable: true,
+  get: function () { return chunkJ76M7XTS_cjs.PositiveInteger; }
+});
+Object.defineProperty(exports, "schedule", {
+  enumerable: true,
+  get: function () { return chunkJ76M7XTS_cjs.schedule; }
+});
+Object.defineProperty(exports, "sleep", {
+  enumerable: true,
+  get: function () { return chunkJ76M7XTS_cjs.sleep; }
+});
+exports.BoundedInteger = BoundedInteger;
+exports.DecodedEventReader = DecodedEventReader;
+exports.ExponentialBackoff = ExponentialBackoff;
+exports.HandedOutLedger = HandedOutLedger;
+exports.LaneLeaseTokenFormat = LaneLeaseTokenFormat;
+exports.NonEmptyText = NonEmptyText;
+exports.OwnerSerializedClaims = OwnerSerializedClaims;
+exports.SubscribingTransport = SubscribingTransport;
+exports.assertPositiveInteger = assertPositiveInteger;
+exports.createCloudEventReaders = createCloudEventReaders;
+exports.createJsonEnvelopeFormat = createJsonEnvelopeFormat;
+exports.fromHeader = fromHeader;
+exports.fromPayloadField = fromPayloadField;
+exports.isJsonObject = isJsonObject;
+exports.mediaTypeOf = mediaTypeOf;
+exports.observeRejection = observeRejection;
+exports.writeStructuredCloudEvent = writeStructuredCloudEvent;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map