@cosyte/astm 0.1.2 → 0.1.4

package/dist/index.d.cts

@@ -515,9 +515,12 @@ declare const WARNING_CODES: {
      */
     readonly ASTM_RECORD_UNINTERPRETED_QUERY_STATUS: "ASTM_RECORD_UNINTERPRETED_QUERY_STATUS";
     /**
-     * A message carried **both** a `Q` (request) and an `R` (result) record: a contradictory shape. The
-     * message is classified `host-query` (the `Q` **dominates**, so it is never read as a result set) and
+     * The stream carried **both** a `Q` (request) and an `R` (result) record: a contradictory shape. The
+     * stream is classified `host-query` (the `Q` **dominates**, so it is never read as a result set) and
      * this warning flags the anomaly. Positional context only; no field value.
+     *
+     * Classification is folded over the whole stream, so a `Q` in one message and an `R` in another
+     * raise it too. `classifyMessage(m.records)` over `messages()` says which message carried which.
      */
     readonly ASTM_RECORD_AMBIGUOUS_MESSAGE_KIND: "ASTM_RECORD_AMBIGUOUS_MESSAGE_KIND";
     /**
@@ -941,10 +944,10 @@ declare function partialTimestamp(position: AstmPosition): AstmRecordWarning;
  */
 declare function uninterpretedQueryStatus(position: AstmPosition): AstmRecordWarning;
 /**
- * Build an `ASTM_RECORD_AMBIGUOUS_MESSAGE_KIND` warning. Emitted when a message
- * carries both a `Q` (request) and an `R` (result) record; the message is
- * classified as a host-query request (the `Q` dominates) and the anomaly is
- * flagged.
+ * Build an `ASTM_RECORD_AMBIGUOUS_MESSAGE_KIND` warning. Emitted when a parsed
+ * stream carries both a `Q` (request) and an `R` (result) record, in one message
+ * or across several; the stream is classified as a host-query request (the `Q`
+ * dominates) and the anomaly is flagged.
  *
  * @example
  * ```ts
@@ -2487,8 +2490,11 @@ interface CommentRecord extends RecordBase {
  * The `Q` (Request Information) record: the host-query request.
  *
  * A `Q` record asks the LIS for information (e.g. outstanding orders for a
- * specimen); its **presence classifies the whole message as a request, never a
- * result set** (see {@link AstmMessage.classification}). Its safety-relevant
+ * specimen); its **presence classifies the records it arrives in as a request,
+ * never a result set**. {@link AstmMessage.classification} is folded over the
+ * whole parsed stream, so a `Q` in any one message makes the whole stream read as
+ * a host query; `classifyMessage(m.records)` classifies one message from
+ * `messages()` on its own. Its safety-relevant
  * fields, the starting/ending range ID and the request-information status, are
  * surfaced **verbatim**; the field *positions* are the public ASTM E1394 layout,
  * but their internal structure and code meanings are **`[OSS-derived / paywalled]`**
@@ -2589,10 +2595,11 @@ interface TerminatorRecord extends RecordBase {
  * arrives here instead, opens no message, and the messages either side of it are
  * grouped as one. Check `rawType` before trusting a split.
  *
- * **And one of these may be a `Q`.** Message classification counts type letters
- * too, so a message carrying an unsupported record is classified `indeterminate`
- * unless a `Q` was read outright: see
- * {@link AstmMessageClassification.hasUnrecognized}.
+ * **And one of these may be a `Q`.** Classification counts type letters too, so
+ * records that include an unsupported one are classified `indeterminate` unless a
+ * `Q` was read outright. On {@link AstmMessage.classification} that is every
+ * record in the stream, so one unsupported record in any message withholds the
+ * kind for the whole stream: see {@link AstmMessageClassification.hasUnrecognized}.
  *
  * **A header that arrives here also failed to re-scope the delimiters.** The
  * records after it are read with the set already in force, and where that set is
@@ -2607,12 +2614,13 @@ interface UnsupportedRecord extends RecordBase {
 /** The discriminated union of every parsed record. */
 type AstmRecord = HeaderRecord | PatientRecord | OrderRecord | ResultRecord | CommentRecord | QueryRecord | ManufacturerRecord | ScientificRecord | TerminatorRecord | UnsupportedRecord;
 /**
- * How a message is classified by the host-query flow.
+ * How the host-query flow classifies a set of records: one message's under
+ * `classifyMessage(m.records)`, the whole stream's on {@link AstmMessage.classification}.
  *
- * - `host-query` (the message carries at least one `Q` record): it is a **request
+ * - `host-query` (the records include at least one `Q`): it is a **request
  *   for information**, and **must never be read as a result set** (the load-bearing
  *   safety distinction of this layer). `Q` **dominates**: a `Q` present classifies
- *   the message as a request even if a result record is also present (an anomaly,
+ *   the records as a request even if a result record is also present (an anomaly,
  *   separately warned), so a `Q`-bearing message is never silently treated as a
  *   result upload.
  * - `results` (no `Q`, at least one `R` result record): a result upload / response.
@@ -2623,9 +2631,16 @@ type AstmRecord = HeaderRecord | PatientRecord | OrderRecord | ResultRecord | Co
  */
 type AstmMessageKind = "host-query" | "results" | "orders" | "indeterminate";
 /**
- * The message-level classification from the host-query flow. `isHostQueryRequest`
- * is the single boolean a consumer should gate on before treating records as
- * results: it is `true` **iff** a `Q` record is present.
+ * The host-query classification of a set of records. `isHostQueryRequest` is the
+ * single boolean a consumer should gate on before treating records as results: it
+ * is `true` **iff** a `Q` record is present among the records classified.
+ *
+ * Which records those are depends on where it comes from. On
+ * {@link AstmMessage.classification} it is folded over **every record in the
+ * stream**, not one message: a stream carrying several `H` … `L` messages gets one
+ * classification, so a `Q` in any message makes the whole stream read as a host
+ * query. `classifyMessage(m.records)`, on a message from `messages()`, gives
+ * that one message's classification.
  *
  * @example
  * ```ts
@@ -2637,9 +2652,9 @@ type AstmMessageKind = "host-query" | "results" | "orders" | "indeterminate";
  */
 interface AstmMessageClassification {
     /**
-     * The message kind.
+     * The kind of the records classified.
      *
-     * `indeterminate` also covers a message the reader declines to classify: when
+     * `indeterminate` also covers records the reader declines to classify: when
      * {@link AstmMessageClassification.hasUnrecognized} is `true` and no `Q` was read, the kind is
      * withheld rather than guessed, because the unreadable letter may have been that `Q`. The `has*`
      * flags below stay truthful in that case, so a caller that wants the raw counts still has them.
@@ -2655,7 +2670,7 @@ interface AstmMessageClassification {
      * At least one record's type letter was **not recognized** (an
      * {@link UnsupportedRecord}), so the letter counts above are known to be incomplete.
      *
-     * Any of them may have been a `Q`, which is why a message carrying one is classified
+     * Any of them may have been a `Q`, which is why records that include one are classified
      * `indeterminate` unless a `Q` was read outright. `ASTM_RECORD_UNKNOWN_TYPE` reports the same
      * condition on {@link AstmMessage.warnings}.
      */
@@ -2664,7 +2679,7 @@ interface AstmMessageClassification {
      * `true` **iff** `kind === "host-query"` (a `Q` record was read), the safety surface: gate on this
      * before treating records as results, so a query is never misread as a result upload.
      *
-     * `false` is **not** a warrant that the message is a result set. Read `kind` for that: it is
+     * `false` is **not** a warrant that the records are a result set. Read `kind` for that: it is
      * `indeterminate` whenever the reader could not account for every type letter.
      */
     readonly isHostQueryRequest: boolean;
@@ -2695,10 +2710,14 @@ interface AstmMessage {
      */
     readonly delimiters: Delimiters;
     /**
-     * The host-query classification of this message: whether it is a request (`Q`
-     * present), a result upload, an order download, or indeterminate. Gate on
-     * {@link AstmMessageClassification.isHostQueryRequest} before reading records as
-     * results.
+     * The host-query classification of the **whole stream**: whether its records make a request
+     * (`Q` present), a result upload, an order download, or indeterminate. Gate on
+     * {@link AstmMessageClassification.isHostQueryRequest} before reading records as results.
+     *
+     * It is folded over every record, not per message, and it does not throw on a multi-message
+     * stream. A `Q` in one message makes the whole stream read as a host query, and a stream that
+     * also carries results anywhere raises `ASTM_RECORD_AMBIGUOUS_MESSAGE_KIND`. Classify each
+     * message on its own with `classifyMessage(m.records)` over `messages()`.
      */
     readonly classification: AstmMessageClassification;
     readonly warnings: readonly AstmRecordWarning[];
@@ -3662,8 +3681,8 @@ declare function messages(msg: AstmMessage): readonly AstmStreamMessage[];
  * Classify a record stream by the host-query flow. Pure and total: it only reads
  * the record type letters, never a field value.
  *
- * `Q` dominates: a message with any `Q` record is a `host-query` request even when
- * a result (`R`) record is also present, so a query is never misread as a result
+ * `Q` dominates: records with any `Q` among them are a `host-query` request even
+ * when a result (`R`) record is also present, so a query is never misread as a result
  * upload. (The `Q`+`R` anomaly is separately warned at parse time.)
  *
  * An **unsupported** record letter with no `Q` alongside it yields `indeterminate`,
@@ -3672,8 +3691,13 @@ declare function messages(msg: AstmMessage): readonly AstmStreamMessage[];
  * {@link AstmMessageClassification.hasUnrecognized} reports why the answer is
  * withheld, and the `has*` counts stay truthful throughout.
  *
+ * `parseAstmRecords` applies this to every record in the stream, so
+ * its `classification` answers for the whole stream, not per message.
+ * Pass one message's records (`m.records` for `m` of `messages()`) to classify that
+ * message on its own.
+ *
  * @param records - The parsed records, in wire order.
- * @returns The message classification.
+ * @returns The classification of exactly those records.
  * @example
  * ```ts
  * import { classifyMessage, parseAstmRecords } from "@cosyte/astm";

package/dist/index.d.ts

@@ -515,9 +515,12 @@ declare const WARNING_CODES: {
      */
     readonly ASTM_RECORD_UNINTERPRETED_QUERY_STATUS: "ASTM_RECORD_UNINTERPRETED_QUERY_STATUS";
     /**
-     * A message carried **both** a `Q` (request) and an `R` (result) record: a contradictory shape. The
-     * message is classified `host-query` (the `Q` **dominates**, so it is never read as a result set) and
+     * The stream carried **both** a `Q` (request) and an `R` (result) record: a contradictory shape. The
+     * stream is classified `host-query` (the `Q` **dominates**, so it is never read as a result set) and
      * this warning flags the anomaly. Positional context only; no field value.
+     *
+     * Classification is folded over the whole stream, so a `Q` in one message and an `R` in another
+     * raise it too. `classifyMessage(m.records)` over `messages()` says which message carried which.
      */
     readonly ASTM_RECORD_AMBIGUOUS_MESSAGE_KIND: "ASTM_RECORD_AMBIGUOUS_MESSAGE_KIND";
     /**
@@ -941,10 +944,10 @@ declare function partialTimestamp(position: AstmPosition): AstmRecordWarning;
  */
 declare function uninterpretedQueryStatus(position: AstmPosition): AstmRecordWarning;
 /**
- * Build an `ASTM_RECORD_AMBIGUOUS_MESSAGE_KIND` warning. Emitted when a message
- * carries both a `Q` (request) and an `R` (result) record; the message is
- * classified as a host-query request (the `Q` dominates) and the anomaly is
- * flagged.
+ * Build an `ASTM_RECORD_AMBIGUOUS_MESSAGE_KIND` warning. Emitted when a parsed
+ * stream carries both a `Q` (request) and an `R` (result) record, in one message
+ * or across several; the stream is classified as a host-query request (the `Q`
+ * dominates) and the anomaly is flagged.
  *
  * @example
  * ```ts
@@ -2487,8 +2490,11 @@ interface CommentRecord extends RecordBase {
  * The `Q` (Request Information) record: the host-query request.
  *
  * A `Q` record asks the LIS for information (e.g. outstanding orders for a
- * specimen); its **presence classifies the whole message as a request, never a
- * result set** (see {@link AstmMessage.classification}). Its safety-relevant
+ * specimen); its **presence classifies the records it arrives in as a request,
+ * never a result set**. {@link AstmMessage.classification} is folded over the
+ * whole parsed stream, so a `Q` in any one message makes the whole stream read as
+ * a host query; `classifyMessage(m.records)` classifies one message from
+ * `messages()` on its own. Its safety-relevant
  * fields, the starting/ending range ID and the request-information status, are
  * surfaced **verbatim**; the field *positions* are the public ASTM E1394 layout,
  * but their internal structure and code meanings are **`[OSS-derived / paywalled]`**
@@ -2589,10 +2595,11 @@ interface TerminatorRecord extends RecordBase {
  * arrives here instead, opens no message, and the messages either side of it are
  * grouped as one. Check `rawType` before trusting a split.
  *
- * **And one of these may be a `Q`.** Message classification counts type letters
- * too, so a message carrying an unsupported record is classified `indeterminate`
- * unless a `Q` was read outright: see
- * {@link AstmMessageClassification.hasUnrecognized}.
+ * **And one of these may be a `Q`.** Classification counts type letters too, so
+ * records that include an unsupported one are classified `indeterminate` unless a
+ * `Q` was read outright. On {@link AstmMessage.classification} that is every
+ * record in the stream, so one unsupported record in any message withholds the
+ * kind for the whole stream: see {@link AstmMessageClassification.hasUnrecognized}.
  *
  * **A header that arrives here also failed to re-scope the delimiters.** The
  * records after it are read with the set already in force, and where that set is
@@ -2607,12 +2614,13 @@ interface UnsupportedRecord extends RecordBase {
 /** The discriminated union of every parsed record. */
 type AstmRecord = HeaderRecord | PatientRecord | OrderRecord | ResultRecord | CommentRecord | QueryRecord | ManufacturerRecord | ScientificRecord | TerminatorRecord | UnsupportedRecord;
 /**
- * How a message is classified by the host-query flow.
+ * How the host-query flow classifies a set of records: one message's under
+ * `classifyMessage(m.records)`, the whole stream's on {@link AstmMessage.classification}.
  *
- * - `host-query` (the message carries at least one `Q` record): it is a **request
+ * - `host-query` (the records include at least one `Q`): it is a **request
  *   for information**, and **must never be read as a result set** (the load-bearing
  *   safety distinction of this layer). `Q` **dominates**: a `Q` present classifies
- *   the message as a request even if a result record is also present (an anomaly,
+ *   the records as a request even if a result record is also present (an anomaly,
  *   separately warned), so a `Q`-bearing message is never silently treated as a
  *   result upload.
  * - `results` (no `Q`, at least one `R` result record): a result upload / response.
@@ -2623,9 +2631,16 @@ type AstmRecord = HeaderRecord | PatientRecord | OrderRecord | ResultRecord | Co
  */
 type AstmMessageKind = "host-query" | "results" | "orders" | "indeterminate";
 /**
- * The message-level classification from the host-query flow. `isHostQueryRequest`
- * is the single boolean a consumer should gate on before treating records as
- * results: it is `true` **iff** a `Q` record is present.
+ * The host-query classification of a set of records. `isHostQueryRequest` is the
+ * single boolean a consumer should gate on before treating records as results: it
+ * is `true` **iff** a `Q` record is present among the records classified.
+ *
+ * Which records those are depends on where it comes from. On
+ * {@link AstmMessage.classification} it is folded over **every record in the
+ * stream**, not one message: a stream carrying several `H` … `L` messages gets one
+ * classification, so a `Q` in any message makes the whole stream read as a host
+ * query. `classifyMessage(m.records)`, on a message from `messages()`, gives
+ * that one message's classification.
  *
  * @example
  * ```ts
@@ -2637,9 +2652,9 @@ type AstmMessageKind = "host-query" | "results" | "orders" | "indeterminate";
  */
 interface AstmMessageClassification {
     /**
-     * The message kind.
+     * The kind of the records classified.
      *
-     * `indeterminate` also covers a message the reader declines to classify: when
+     * `indeterminate` also covers records the reader declines to classify: when
      * {@link AstmMessageClassification.hasUnrecognized} is `true` and no `Q` was read, the kind is
      * withheld rather than guessed, because the unreadable letter may have been that `Q`. The `has*`
      * flags below stay truthful in that case, so a caller that wants the raw counts still has them.
@@ -2655,7 +2670,7 @@ interface AstmMessageClassification {
      * At least one record's type letter was **not recognized** (an
      * {@link UnsupportedRecord}), so the letter counts above are known to be incomplete.
      *
-     * Any of them may have been a `Q`, which is why a message carrying one is classified
+     * Any of them may have been a `Q`, which is why records that include one are classified
      * `indeterminate` unless a `Q` was read outright. `ASTM_RECORD_UNKNOWN_TYPE` reports the same
      * condition on {@link AstmMessage.warnings}.
      */
@@ -2664,7 +2679,7 @@ interface AstmMessageClassification {
      * `true` **iff** `kind === "host-query"` (a `Q` record was read), the safety surface: gate on this
      * before treating records as results, so a query is never misread as a result upload.
      *
-     * `false` is **not** a warrant that the message is a result set. Read `kind` for that: it is
+     * `false` is **not** a warrant that the records are a result set. Read `kind` for that: it is
      * `indeterminate` whenever the reader could not account for every type letter.
      */
     readonly isHostQueryRequest: boolean;
@@ -2695,10 +2710,14 @@ interface AstmMessage {
      */
     readonly delimiters: Delimiters;
     /**
-     * The host-query classification of this message: whether it is a request (`Q`
-     * present), a result upload, an order download, or indeterminate. Gate on
-     * {@link AstmMessageClassification.isHostQueryRequest} before reading records as
-     * results.
+     * The host-query classification of the **whole stream**: whether its records make a request
+     * (`Q` present), a result upload, an order download, or indeterminate. Gate on
+     * {@link AstmMessageClassification.isHostQueryRequest} before reading records as results.
+     *
+     * It is folded over every record, not per message, and it does not throw on a multi-message
+     * stream. A `Q` in one message makes the whole stream read as a host query, and a stream that
+     * also carries results anywhere raises `ASTM_RECORD_AMBIGUOUS_MESSAGE_KIND`. Classify each
+     * message on its own with `classifyMessage(m.records)` over `messages()`.
      */
     readonly classification: AstmMessageClassification;
     readonly warnings: readonly AstmRecordWarning[];
@@ -3662,8 +3681,8 @@ declare function messages(msg: AstmMessage): readonly AstmStreamMessage[];
  * Classify a record stream by the host-query flow. Pure and total: it only reads
  * the record type letters, never a field value.
  *
- * `Q` dominates: a message with any `Q` record is a `host-query` request even when
- * a result (`R`) record is also present, so a query is never misread as a result
+ * `Q` dominates: records with any `Q` among them are a `host-query` request even
+ * when a result (`R`) record is also present, so a query is never misread as a result
  * upload. (The `Q`+`R` anomaly is separately warned at parse time.)
  *
  * An **unsupported** record letter with no `Q` alongside it yields `indeterminate`,
@@ -3672,8 +3691,13 @@ declare function messages(msg: AstmMessage): readonly AstmStreamMessage[];
  * {@link AstmMessageClassification.hasUnrecognized} reports why the answer is
  * withheld, and the `has*` counts stay truthful throughout.
  *
+ * `parseAstmRecords` applies this to every record in the stream, so
+ * its `classification` answers for the whole stream, not per message.
+ * Pass one message's records (`m.records` for `m` of `messages()`) to classify that
+ * message on its own.
+ *
  * @param records - The parsed records, in wire order.
- * @returns The message classification.
+ * @returns The classification of exactly those records.
  * @example
  * ```ts
  * import { classifyMessage, parseAstmRecords } from "@cosyte/astm";

package/dist/index.mjs

@@ -618,9 +618,12 @@ var WARNING_CODES = {
    */
   ASTM_RECORD_UNINTERPRETED_QUERY_STATUS: "ASTM_RECORD_UNINTERPRETED_QUERY_STATUS",
   /**
-   * A message carried **both** a `Q` (request) and an `R` (result) record: a contradictory shape. The
-   * message is classified `host-query` (the `Q` **dominates**, so it is never read as a result set) and
+   * The stream carried **both** a `Q` (request) and an `R` (result) record: a contradictory shape. The
+   * stream is classified `host-query` (the `Q` **dominates**, so it is never read as a result set) and
    * this warning flags the anomaly. Positional context only; no field value.
+   *
+   * Classification is folded over the whole stream, so a `Q` in one message and an `R` in another
+   * raise it too. `classifyMessage(m.records)` over `messages()` says which message carried which.
    */
   ASTM_RECORD_AMBIGUOUS_MESSAGE_KIND: "ASTM_RECORD_AMBIGUOUS_MESSAGE_KIND",
   /**
@@ -808,7 +811,7 @@ function uninterpretedQueryStatus(position) {
 function ambiguousMessageKind(position) {
   return {
     code: WARNING_CODES.ASTM_RECORD_AMBIGUOUS_MESSAGE_KIND,
-    message: "Message carried both a Q (request) and an R (result) record, classified host-query; Q dominates.",
+    message: "Stream carried both a Q (request) and an R (result) record, classified host-query; Q dominates.",
     position
   };
 }
@@ -1936,7 +1939,7 @@ function parseDateField(raw, recordIndex, recordType, fieldIndex, warnings) {
   return date;
 }
 function isNumericValue(value) {
-  return /^\s*[<>]?\s*-?\d+(?:\.\d+)?\s*$/u.test(value);
+  return /^\s*(?:[<>]\s*)?-?\d+(?:\.\d+)?\s*$/u.test(value);
 }
 function fieldRaw(field) {
   return field !== void 0 && field.raw.length > 0 ? field.raw : void 0;
@@ -3142,7 +3145,7 @@ function concatBytes3(chunks) {
 }
 
 // src/index.ts
-var VERSION = "0.1.2";
+var VERSION = "0.1.4";
 
 export { ABNORMAL_FLAG_CODES, ABNORMAL_FLAG_VOCABULARY, ALL_ASTM_WARNING_CODES, AMBIGUOUS_CODES, ACK as ASTM_ACK, ENQ as ASTM_ENQ, EOT as ASTM_EOT, NAK as ASTM_NAK, AstmAmbiguousStreamError, AstmFrameEncodeError, AstmFrameStrictError, AstmParseError, AstmProfileDefinitionError, AstmSerializeError, AstmStrictError, CANONICAL_DELIMITERS, FATAL_CODES, FRAME_WARNING_CODES, LIVD_CATALOG_IDENTITY_UNDECLARED, LIVD_WARNING_CODES, LTP_WARNING_CODES, RESULT_STATUS_VOCABULARY, SAFETY_CRITICAL_CODES, TOLERABLE_CODES, VERSION, WARNING_CODES, alignmentShiftedComponents, alignmentShiftedFields, alignmentTruncatedField, ambiguousEscapeAlignment, ambiguousMessageKind, ambiguousValueSplit, applyAstmProfile, applyAstmProfileToWarnings, applyLivd, astmDateToLocalISO, astmProfiles, attachComments, buildAstmMessage, classifyMessage, comments, commentsFor, composeAstmFrames, computeChecksum, decodeAstmFrames, decodeEscapes, deepFreeze, defineAstmProfile, defineLivdCatalog, delimiterRoleCollision, delimiterSwallowedByEscape, delimitersRedeclared, describeVocabulary, detectFraming, encodeComponent, fieldScalar, fieldsUnseparated, frameBadChecksum, frameOversize, frameSequenceGap, frameUnterminated, getAstmProfile, getDefaultAstmProfile, hasCollidingRoles, interpretAbnormalFlag, interpretResultStatus, isNonStandard, isSafetyCriticalCode, listAstmProfiles, livdAmbiguousMapping, livdCatalogMissingLoincVersion, livdUnmappedCode, lookupLivdForRecord, ltpAmbiguousTransport, ltpFrameRejected, ltpInitialState, ltpReduce, ltpUnexpectedEvent, messages, nonStandardDelimiters, orders, orphanComment, parseAstmDate, parseAstmRecords, parseChecksumHex, parseFramedAstm, parseReferenceRange, partialTimestamp, patient, primaryCode, profileQuirkApplied, query, readDelimiterDeclaration, readDelimiters, recognizeUniversalTestId, resolveProfileTransport, results, serializeAstmRecord, serializeAstmRecords, serializeField, serializeFramedAstm, setDefaultAstmProfile, splitEscapeAware, toChecksumHex, toDate, toISO, toObject, tokenizeHeader, tokenizeRecord, undefinedAbnormalFlag, undefinedResultStatus, uninterpretedQueryStatus, unitsAbsent, unknownEscapeSequence, unknownRecordType, unpairedEscapeCharacter, unparseableReferenceRange, unreadableRedeclaration };
 //# sourceMappingURL=index.mjs.map