@glion/mllp-client 0.19.0 → 0.20.0

package/dist/index.js

@@ -1,3 +1,4 @@
+import { n as MllpClientError, r as MllpErrorCode, t as MllpInvalidOptionError } from "./chunks/mllp-invalid-option-error.js";
 import { MllpCodecError, frame, unframe } from "@glion/mllp-codec";
 import { AckApplicationError, AckApplicationReject, AckCode, AckCommitError, AckCommitReject, isAckNakCode, isAckSuccessCode } from "@glion/ack";
 import { value } from "@glion/util-query";
@@ -11,57 +12,17 @@ import { decodeBytes, encodeBytes } from "@glion/util-charset";
 */
 const MAX_TIMEOUT_MS = 2 ** 31 - 1;
 //#endregion
-//#region src/errors/base.ts
-/**
-* The base every client error extends, and what each one carries: a fixed
-* `code`, a fixed message, what became of the message, and the lower layer's
-* failure on `cause`.
-*
-* @module
-*/
-const MllpErrorCode = {
-	ALREADY_SENDING: "ALREADY_SENDING",
-	CLOSED: "CLOSED",
-	CONNECTION_FAILED: "CONNECTION_FAILED",
-	CONNECTION_LOST: "CONNECTION_LOST",
-	CONNECTION_TIMEOUT: "CONNECTION_TIMEOUT",
-	INVALID_MESSAGE: "INVALID_MESSAGE",
-	INVALID_OPTION: "INVALID_OPTION",
-	INVALID_RESPONSE: "INVALID_RESPONSE",
-	SEND_ABORTED: "SEND_ABORTED",
-	SEND_TIMEOUT: "SEND_TIMEOUT"
-};
-var MllpClientError = class extends Error {};
-//#endregion
-//#region src/errors/mllp-already-sending-error.ts
-/**
-* `send()` was called while another message was still waiting for its
-* acknowledgment. The client sends one message at a time.
-*/
-var MllpAlreadySendingError = class extends MllpClientError {
-	name = "MllpAlreadySendingError";
-	code = MllpErrorCode.ALREADY_SENDING;
-	delivery = "not-sent";
-	/** MSH-10 of the message that is still waiting. */
-	controlId;
-	constructor(controlId) {
-		super("Cannot send: another message is still waiting for its acknowledgment — await the in-flight send() first.");
-		this.controlId = controlId;
-	}
-};
-//#endregion
 //#region src/errors/mllp-client-closed-error.ts
 /**
 * The call cannot be served: the client is closed, by `close()`, by
-* `destroy()`, or by a lost connection the reconnect policy did not restore.
-* That last failure is on `cause`.
+* `destroy()`, or by a failure. The failure is on `cause`.
 */
 var MllpClientClosedError = class extends MllpClientError {
 	name = "MllpClientClosedError";
 	code = MllpErrorCode.CLOSED;
 	delivery = "not-sent";
 	constructor(cause = null) {
-		super(cause === null ? "The client is closed — construct a new MllpClient to send again." : "The client closed after its connection could not be restored — construct a new MllpClient to send again.", { cause: cause ?? void 0 });
+		super(cause === null ? "The client is closed — construct a new MllpClient to send again." : "The client closed on a failure, see cause — construct a new MllpClient to send again.", { cause: cause ?? void 0 });
 	}
 };
 //#endregion
@@ -133,14 +94,6 @@ var MllpInvalidMessageError = class extends MllpClientError {
 	}
 };
 //#endregion
-//#region src/errors/mllp-invalid-option-error.ts
-/** An option is out of range. Raised before anything happens. */
-var MllpInvalidOptionError = class extends MllpClientError {
-	name = "MllpInvalidOptionError";
-	code = MllpErrorCode.INVALID_OPTION;
-	delivery = "not-sent";
-};
-//#endregion
 //#region src/errors/mllp-invalid-response-error.ts
 /**
 * The reply was not a usable acknowledgment of the message that was waiting:
@@ -238,8 +191,10 @@ var MllpSendTimeoutError = class extends MllpConnectionError {
 //#endregion
 //#region src/assertions.ts
 /**
-* Option validation. Each `assert*` throws {@link MllpInvalidOptionError} for
-* an option a caller passed out of range, before anything happens.
+* Option validation, and the client's invariants. Each option `assert*`
+* throws {@link MllpInvalidOptionError} for an option a caller passed out of
+* range, before anything happens. {@link assertPhase} throws for a phase the
+* client cannot be in where it is asserted: a bug.
 *
 * @module
 */
@@ -249,6 +204,10 @@ function assertTimeoutMs(option, ms) {
 function assertByteCap(bytes) {
 	if (!Number.isInteger(bytes) || bytes <= 0) throw new MllpInvalidOptionError("maxBufferedBytes must be a positive integer.");
 }
+/** `state` is in `phase`; `where` names the site for the report. */
+function assertPhase(state, phase, where) {
+	if (state.phase !== phase) throw new Error(`${where} found the client ${state.phase}. This is a bug in @glion/mllp-client; please report it.`);
+}
 function assertReconnectAttempts(attempts) {
 	if (!(attempts === Number.POSITIVE_INFINITY) && (!Number.isInteger(attempts) || attempts < 0)) throw new MllpInvalidOptionError("reconnect.attempts must be a non-negative integer, or Infinity.");
 }
@@ -306,13 +265,17 @@ function encode(tree) {
 	}
 }
 /**
-* `bytes` as the reply to the message `controlId` identifies.
+* `bytes` as the acknowledgment of the message `controlId` identifies.
 *
 * MSA-2 is checked before MSA-1 is read: an accept or a NAK is reported only
 * for the message it answers. MSH-9 and the HL7 version are not checked
 * (#668).
 *
-* Never throws.
+* @throws {AckException} MSA-1 refused the message. The remote system
+*   understood it.
+* @throws {MllpInvalidResponseError} Not a usable acknowledgment of this
+*   message: unreadable bytes, an MSA-1 outside Table 0008, or an MSA-2
+*   naming another message.
 */
 function decode(bytes, controlId) {
 	let raw;
@@ -321,32 +284,59 @@ function decode(bytes, controlId) {
 		raw = decodeBytes(bytes);
 		tree = parseHL7v2(raw);
 	} catch (error) {
-		return invalid(error, controlId);
+		throw new MllpInvalidResponseError(error, controlId);
 	}
 	const answers = read(tree, "MSA-2[1].1.1");
-	if (answers !== controlId) return invalid(`MSA-2 is "${answers}", so it answers a different message — usually a late acknowledgment from an earlier timed-out send.`, controlId);
+	if (answers !== controlId) throw new MllpInvalidResponseError(`MSA-2 is "${answers}", so it answers a different message — usually a late acknowledgment from an earlier timed-out send.`, controlId);
 	const code = read(tree, "MSA-1[1].1.1");
-	if (isAckNakCode(code)) return {
-		exception: nakException(tree, code),
-		type: "nak"
-	};
-	if (!isAckSuccessCode(code)) return invalid(code === "" ? "MSA-1 is empty, so accept or reject cannot be determined." : `MSA-1 is "${code}", which is not one of AA, AE, AR, CA, CE, or CR.`, controlId);
+	if (isAckNakCode(code)) throw nakException(tree, code);
+	if (!isAckSuccessCode(code)) throw new MllpInvalidResponseError(code === "" ? "MSA-1 is empty, so accept or reject cannot be determined." : `MSA-1 is "${code}", which is not one of AA, AE, AR, CA, CE, or CR.`, controlId);
 	return {
-		response: {
-			code,
-			controlId: answers,
-			id: read(tree, "MSH-10[1].1.1"),
-			raw,
-			text: read(tree, "MSA-3[1].1.1") || void 0,
-			tree
-		},
-		type: "accept"
+		code,
+		controlId: answers,
+		id: read(tree, "MSH-10[1].1.1"),
+		raw,
+		text: read(tree, "MSA-3[1].1.1") || void 0,
+		tree
 	};
 }
-function invalid(reason, controlId) {
+//#endregion
+//#region src/queue.ts
+function createQueue() {
+	const entries = [];
+	let empty = null;
 	return {
-		error: new MllpInvalidResponseError(reason, controlId),
-		type: "invalid"
+		async drained() {
+			if (entries.length === 0) return;
+			empty ??= Promise.withResolvers();
+			await empty.promise;
+		},
+		enter() {
+			const { promise, resolve, reject } = Promise.withResolvers();
+			const entry = {
+				reject,
+				resolve: () => resolve(null),
+				wait: entries.length === 0 ? null : promise
+			};
+			entries.push(entry);
+			return entry;
+		},
+		leave(turn) {
+			const place = entries.indexOf(turn);
+			if (place === -1) throw new Error("A turn left the queue twice. This is a bug in @glion/mllp-client; please report it.");
+			entries.splice(place, 1);
+			if (place === 0) entries[0]?.resolve();
+			if (entries.length === 0) {
+				empty?.resolve();
+				empty = null;
+			}
+		},
+		get pending() {
+			return Math.max(0, entries.length - 1);
+		},
+		rejectWaiting(error) {
+			for (const entry of entries.slice(1)) entry.reject(error);
+		}
 	};
 }
 //#endregion
@@ -488,9 +478,10 @@ function createSession(socket, opts, signal) {
 * Sends HL7v2 messages to one remote system over MLLP and returns each
 * message's acknowledgment.
 *
-* One client owns one socket and sends one message at a time. `send()` writes
-* the message, waits for the acknowledgment, checks that it answers this
-* message, and resolves with it.
+* One client owns one socket and puts one message on the wire at a time.
+* `send()` writes the message, waits for the acknowledgment, checks that it
+* answers this message, and resolves with it. A send arriving while another
+* is in flight waits its turn; sends go out in the order they were called.
 *
 * ```ts
 * import { MllpClient } from "@glion/mllp-client";
@@ -524,6 +515,7 @@ var MllpClient = class extends MllpClientEmitter {
 	#policy;
 	#sendTimeoutMs;
 	#state = { phase: "idle" };
+	#queue = createQueue();
 	/**
 	* @throws {MllpInvalidOptionError} A timeout, byte cap, or attempt count is
 	*   out of range.
@@ -556,6 +548,10 @@ var MllpClient = class extends MllpClientEmitter {
 	get state() {
 		return this.#state.phase;
 	}
+	/** How many sends wait their turn, the one in flight excluded. */
+	get pending() {
+		return this.#queue.pending;
+	}
 	/** Whether the connection is open. True in both `connected` and `sending`. */
 	get connected() {
 		const { phase } = this.#state;
@@ -571,44 +567,58 @@ var MllpClient = class extends MllpClientEmitter {
 	* @throws {MllpConnectionFailedError} The last attempt could not open the
 	*   socket.
 	* @throws {MllpConnectionTimeoutError} The last attempt did not open in time.
-	* @throws {MllpClientClosedError} The client is closed, or `close()` arrived
-	*   while the connection was still being established.
+	* @throws {MllpClientClosedError} The client is closed, or `close()` or
+	*   `destroy()` arrived while the connection was still being established.
 	*/
 	async connect() {
 		const state = this.#state;
+		let opening;
 		switch (state.phase) {
 			case "connected":
 			case "sending": return;
-			case "connecting":
-				await state.opening;
-				return;
-			case "closing": throw new MllpClientClosedError();
+			case "closing":
 			case "closed": throw new MllpClientClosedError(state.reason);
+			case "connecting":
+				opening = state.opening;
+				break;
 			case "idle": {
 				const abort = new AbortController();
-				const opening = this.#dial(abort.signal);
+				opening = this.#dial(abort.signal);
 				this.#state = {
 					abort,
 					opening,
 					phase: "connecting"
 				};
-				await opening;
+				break;
 			}
 		}
+		try {
+			await opening;
+		} catch (error) {
+			if (error instanceof MllpConnectionError) await this.destroy(error);
+			throw error;
+		}
 	}
 	/**
 	* Sends one message and returns its acknowledgment. Connects first when the
-	* client is not connected yet.
+	* client is not connected yet, and waits for the send in flight, if any,
+	* before writing.
+	*
+	* Sends go out in the order `send()` was called. The queue has no bound.
+	* `timeoutMs` runs from the moment the write starts, not from the call. A
+	* send still waiting when the client closes rejects with
+	* {@link MllpClientClosedError}; one waiting behind a dial that fails
+	* rejects with the dial's error, as `connect()` does.
 	*
 	* Nothing is written when an option, phase, or message error is thrown.
-	* Every other failure also closes the client.
+	* Every wire failure also closes the client; a NAK does not.
 	*
 	* @throws {AckException} The remote system answered with a NAK. The
 	*   connection stays open.
 	* @throws {MllpInvalidOptionError} `timeoutMs` is out of range.
 	* @throws {MllpInvalidMessageError} The message cannot be sent as-is.
-	* @throws {MllpClientClosedError} The client is closed.
-	* @throws {MllpAlreadySendingError} Another send is in flight.
+	* @throws {MllpClientClosedError} The client is closed, or closed while
+	*   this send was waiting its turn.
 	* @throws {MllpConnectionFailedError} The connection could not be opened.
 	* @throws {MllpConnectionTimeoutError} The connection did not open in time.
 	* @throws {MllpSendTimeoutError} No acknowledgment arrived in time.
@@ -621,65 +631,99 @@ var MllpClient = class extends MllpClientEmitter {
 		const timeoutMs = opts.timeoutMs ?? this.#sendTimeoutMs;
 		assertTimeoutMs("timeoutMs", timeoutMs);
 		const { bytes, controlId } = encode(message);
-		if (!this.connected) await this.connect();
-		const state = this.#state;
-		switch (state.phase) {
-			case "sending": throw new MllpAlreadySendingError(state.controlId);
-			case "closing": throw new MllpClientClosedError();
-			case "closed": throw new MllpClientClosedError(state.reason);
-			case "idle":
-			case "connecting": throw new Error(`send() found the client ${state.phase} after it connected. This is a bug in @glion/mllp-client; please report it.`);
-			case "connected": break;
+		const at = this.#state;
+		if (at.phase === "closing" || at.phase === "closed") throw new MllpClientClosedError(at.reason);
+		const turn = this.#queue.enter();
+		try {
+			if (turn.wait !== null) await turn.wait;
+			if (!this.connected) await this.connect();
+			return await this.#send(controlId, bytes, timeoutMs);
+		} finally {
+			this.#queue.leave(turn);
 		}
-		const done = this.#send(state.session, controlId, bytes, timeoutMs);
-		this.#state = {
-			controlId,
-			done,
-			phase: "sending",
-			session: state.session
-		};
-		return await done;
 	}
 	/**
 	* Ends the connection once the message in flight is acknowledged, and
-	* resolves when it is down. New sends are refused from the moment this is
-	* called. An attempt to connect stops at once.
+	* resolves when it is down. New sends, and sends waiting their turn, are
+	* refused from the moment this is called. An attempt to connect stops at
+	* once.
 	*
 	* Resolves from any phase. Never rejects. Idempotent. The wait is bounded by
 	* the in-flight send's own deadline; {@link destroy} does not wait at all.
+	* If the message it waits for fails, the client closes with that failure;
+	* otherwise with `null`.
 	*/
 	async close() {
 		const from = this.#state;
-		if (from.phase === "sending") {
-			this.#state = {
-				done: from.done,
-				phase: "closing",
-				session: from.session
-			};
-			await Promise.allSettled([from.done]);
+		switch (from.phase) {
+			case "closing":
+				await from.closed;
+				return;
+			case "sending": {
+				const closed = (async () => {
+					await this.#queue.drained();
+					await this.#destroy(from, null);
+				})();
+				this.#state = {
+					closed,
+					phase: "closing",
+					reason: null,
+					session: from.session
+				};
+				this.#queue.rejectWaiting(new MllpClientClosedError());
+				await closed;
+				return;
+			}
+			case "idle":
+			case "connecting":
+			case "connected":
+			case "closed": await this.destroy();
 		}
-		await this.destroy();
 	}
 	/**
 	* Ends the connection now, and resolves when it is down. A message in flight
 	* rejects with {@link MllpSendAbortedError}. An attempt to connect stops at
-	* once.
+	* once. The client closes with `reason`: the failure it reports on `close`
+	* and on every later call, or `null` for the owner's own decision.
 	*
-	* Resolves from any phase. Never rejects. Idempotent.
+	* Resolves from any phase. Never rejects. Idempotent. Sends waiting their
+	* turn are rejected with `reason` when its delivery is `not-sent`, and with
+	* {@link MllpClientClosedError} carrying `reason` otherwise. Arriving while
+	* the client is already closing, it cuts the message in flight and joins
+	* the ending under way; `reason` is recorded when no failure is known yet.
 	*/
-	async destroy() {
+	async destroy(reason = null) {
 		const from = this.#state;
-		this.#closed(null);
 		switch (from.phase) {
-			case "idle":
 			case "closed": return;
-			case "connecting":
-				from.abort.abort();
-				await Promise.allSettled([from.opening]);
+			case "closing":
+				if (from.reason === null && reason !== null) this.#state = {
+					...from,
+					reason
+				};
+				await from.session?.destroy();
+				await from.closed;
 				return;
+			case "idle":
+				this.#state = {
+					phase: "closed",
+					reason
+				};
+				this.emit("close", reason);
+				return;
+			case "connecting":
 			case "connected":
-			case "sending":
-			case "closing": await from.session.destroy();
+			case "sending": {
+				const closed = this.#destroy(from, reason);
+				this.#state = {
+					closed,
+					phase: "closing",
+					reason,
+					session: "session" in from ? from.session : null
+				};
+				this.#queue.rejectWaiting(reason?.delivery === "not-sent" ? reason : new MllpClientClosedError(reason));
+				await closed;
+			}
 		}
 	}
 	/** Calls {@link close}. Enables `await using`. */
@@ -689,30 +733,30 @@ var MllpClient = class extends MllpClientEmitter {
 	/**
 	* Dials under the policy until a session opens, then moves to `connected`
 	* and reports `connect`. Each attempt after the first waits
-	* `delay(attempt)` first. Once the policy gives up, closes the client with
-	* the last attempt's failure.
+	* `delay(attempt)` first.
 	*
 	* @throws {MllpClientClosedError} `signal` aborted: the owner closed the
 	*   client. Nothing is left open.
-	* @throws {MllpConnectionFailedError} The last attempt could not open the
-	*   socket.
-	* @throws {MllpConnectionTimeoutError} The last attempt did not open in
-	* time.
+	* @throws {MllpConnectionFailedError} The policy gave up; the last attempt
+	*   could not open the socket.
+	* @throws {MllpConnectionTimeoutError} The policy gave up; the last attempt
+	*   did not open in time.
 	*/
 	async #dial(signal) {
 		for (let attempt = 0;; attempt += 1) {
 			if (attempt > 0) await sleep(this.#policy.delay(attempt), signal);
-			if (signal.aborted) throw new MllpClientClosedError();
+			if (signal.aborted) throw new MllpClientClosedError(signal.reason);
 			const session = createSession(this.#socket, this.#connect, signal);
 			try {
 				await session.ready;
 			} catch (error) {
-				this.#failed(attempt, error, signal);
+				if (signal.aborted) throw new MllpClientClosedError(signal.reason);
+				if (attempt >= this.#policy.attempts) throw error;
 				continue;
 			}
 			if (signal.aborted) {
 				await session.destroy();
-				throw new MllpClientClosedError();
+				throw new MllpClientClosedError(signal.reason);
 			}
 			this.#state = {
 				phase: "connected",
@@ -723,37 +767,51 @@ var MllpClient = class extends MllpClientEmitter {
 		}
 	}
 	/**
-	* Attempt `attempt` failed with `error`: returns when the policy allows
-	* another. Throws `MllpClientClosedError` once `signal` has aborted, and
-	* `error` once the policy is out of attempts, the client closed with it.
-	*/
-	#failed(attempt, error, signal) {
-		if (signal.aborted) throw new MllpClientClosedError();
-		if (attempt < this.#policy.attempts) return;
-		if (error instanceof MllpConnectionError) this.#closed(error);
-		throw error;
-	}
-	/**
-	* The terminal move, from any phase: `reason` is the failure the client
-	* closes with, or `null` when the owner closes it. Once.
+	* Ends what `from` holds, the dial or the session, then moves to `closed`
+	* with the reason `closing` holds by then and reports `close`. A dial is
+	* aborted with `reason`.
+	*
+	* MUST NOT touch `#state` before its first `await`: the caller moves to
+	* `closing` after calling it.
 	*/
-	#closed(reason) {
-		if (this.#state.phase === "closed") return;
+	async #destroy(from, reason) {
+		switch (from.phase) {
+			case "connecting":
+				from.abort.abort(reason);
+				await Promise.allSettled([from.opening]);
+				break;
+			case "connected":
+			case "sending":
+				await from.session.destroy();
+				break;
+		}
+		const ending = this.#state;
+		assertPhase(ending, "closing", "The teardown");
 		this.#state = {
 			phase: "closed",
-			reason
+			reason: ending.reason
 		};
-		this.emit("close", reason);
+		this.emit("close", ending.reason);
 	}
 	/**
-	* One message on the wire, and the acknowledgment it comes back with.
+	* The `sending` phase: the message on the wire and its acknowledgment,
+	* from `connected` and back to it.
 	*
-	* Settles when the send is over, however it ended.
+	* A failure of unknown delivery closes the client with it. A NAK, or a
+	* message refused before the write, leaves the connection in step.
 	*/
-	async #send(session, controlId, bytes, timeoutMs) {
+	async #send(controlId, bytes, timeoutMs) {
+		const at = this.#state;
+		assertPhase(at, "connected", "send() at its turn");
+		const { session } = at;
+		this.#state = {
+			phase: "sending",
+			session
+		};
 		try {
-			const reply = await this.#exchange(session, controlId, bytes, timeoutMs);
-			return await this.#readAcknowledgment(session, controlId, reply);
+			return decode(await session.exchange(bytes, timeoutMs), controlId);
+		} catch (error) {
+			return await this.#sendFailed(error, controlId);
 		} finally {
 			if (this.#state.phase === "sending") this.#state = {
 				phase: "connected",
@@ -762,44 +820,24 @@ var MllpClient = class extends MllpClientEmitter {
 		}
 	}
 	/**
-	* The message on the wire, and the reply it must produce to be a send.
-	* Anything else closes the client.
-	*/
-	async #exchange(session, controlId, bytes, timeoutMs) {
-		try {
-			return await session.exchange(bytes, timeoutMs);
-		} catch (error) {
-			if (error instanceof MllpInvalidMessageError) throw error;
-			if (error instanceof MllpCodecError) await this.#fail(session, new MllpInvalidResponseError(error, controlId));
-			if (error instanceof MllpClientError) await this.#fail(session, error);
-			throw error;
-		}
-	}
-	/**
-	* `reply` as this message's acknowledgment.
+	* The send of `controlId` failed with `error`. Throws it as the client
+	* reports it: a reply the codec could not read is
+	* {@link MllpInvalidResponseError}. A failure of unknown delivery, other
+	* than a send cut off by `destroy()`, closes the client first.
 	*
-	* A reply that cannot be read, or that answers another message, closes the
-	* client. A NAK does not.
-	*/
-	async #readAcknowledgment(session, controlId, reply) {
-		const answer = decode(reply, controlId);
-		switch (answer.type) {
-			case "accept": return answer.response;
-			case "nak": throw answer.exception;
-			case "invalid": return await this.#fail(session, answer.error);
-		}
-	}
-	/**
-	* Closes the client with `reason` and ends `session`. Throws `reason` once
-	* the socket is down.
+	* From `closing`, the ending under way is waiting for this send: started,
+	* not awaited.
 	*/
-	async #fail(session, reason) {
-		this.#closed(reason);
-		await session.destroy();
+	async #sendFailed(error, controlId) {
+		const reason = error instanceof MllpCodecError ? new MllpInvalidResponseError(error, controlId) : error;
+		if (!(reason instanceof MllpClientError) || reason.delivery !== "unknown") throw reason;
+		if (reason instanceof MllpSendAbortedError) throw reason;
+		if (this.#state.phase === "sending") await this.destroy(reason);
+		else this.destroy(reason);
 		throw reason;
 	}
 };
 //#endregion
-export { MllpAlreadySendingError, MllpClient, MllpClientClosedError, MllpClientEmitter, MllpClientError, MllpConnectionError, MllpConnectionFailedError, MllpConnectionLostError, MllpConnectionTimeoutError, MllpErrorCode, MllpInvalidMessageError, MllpInvalidOptionError, MllpInvalidResponseError, MllpSendAbortedError, MllpSendTimeoutError };
+export { MllpClient, MllpClientClosedError, MllpClientEmitter, MllpClientError, MllpConnectionError, MllpConnectionFailedError, MllpConnectionLostError, MllpConnectionTimeoutError, MllpErrorCode, MllpInvalidMessageError, MllpInvalidOptionError, MllpInvalidResponseError, MllpSendAbortedError, MllpSendTimeoutError };
 
 //# sourceMappingURL=index.js.map