@optionfactory/fml 8.0.2 → 9.0.0-rc1

package/dist/httpc.mjs

@@ -1,6 +1,11 @@
 /**
  * @typedef {{ type: string; context: string?; reason: string; details: any?; }} Problem
  */
+/**
+ * An error carrying a list of problems rather than one message. A problem's
+ * `context` names the field it belongs to, which is what lets a form show each
+ * one beside its own input instead of in a banner.
+ */
 class Failure extends Error {
     /**
      *
@@ -13,18 +18,55 @@ class Failure extends Error {
         this.name = 'Failure';
         this.problems = problems;
     }
+    /**
+     * Returns a copy whose problems' contexts have the prefix removed, so a
+     * caller can rethrow namespaced problems as its own.
+     * @param {string} prefix
+     * @returns {Failure}
+     */
     dropping(prefix) {
         return new Failure(this.message, Failure.dropProblemsContext(this.problems, prefix), this);
     }
+    /**
+     * @param {Problem[]} problems
+     * @param {string} prefix
+     * @returns {Problem[]}
+     */
     static dropProblemsContext(problems, prefix) {
         return problems.map(({ type, context, reason, details }) => {
             const nctx = context?.startsWith(prefix) ? context.substring(prefix.length) : context;
             return { type, context: nctx, reason, details };
         });
     }
+    /**
+     * The one reading of a failure: its problems' reasons, one per line, or
+     * the fallback when the value carries none. An empty problems array
+     * carries nothing: the failure's own message reads instead.
+     *
+     * @param {any} cause
+     * @param {string|null} [fallback]
+     * @returns {string}
+     */
+    static problemsText(cause, fallback = null) {
+        if (cause?.problems?.length) {
+            return cause.problems.map((p) => `${p.reason}`).join('\n');
+        }
+        return fallback ?? `${cause?.message ?? cause}`;
+    }
 }
 
+/**
+ * Base64 encoding and decoding over ArrayBuffers, in the STANDARD and URL_SAFE
+ * alphabets. The encoder never emits padding; the decoder accepts both padded
+ * and unpadded input, and rejects anything it cannot decode faithfully instead
+ * of corrupting silently.
+ */
 class Base64 {
+    /**
+     * @param {ArrayBuffer} arrayBuffer
+     * @param {string} [dialect] one of Base64.STANDARD or Base64.URL_SAFE, URL_SAFE by default
+     * @returns {string} the unpadded encoding
+     */
     static encode(arrayBuffer, dialect) {
         const d = dialect || Base64.URL_SAFE;
         const len = arrayBuffer.byteLength;
@@ -44,15 +86,32 @@ class Base64 {
         }
         return res;
     }
+    /**
+     * @param {string} str
+     * @param {string} [dialect] one of Base64.STANDARD or Base64.URL_SAFE, URL_SAFE by default
+     * @returns {ArrayBuffer}
+     */
     static decode(str, dialect) {
         const d = dialect || Base64.URL_SAFE;
-        let nbytes = Math.floor(str.length * 0.75);
-        for (let i = 0; i !== str.length; ++i) {
-            if (str[str.length - i - 1] !== '=') {
-                break;
+        //padding belongs at the tail only, two at most, and nothing outside the
+        //dialect decodes: reject instead of corrupting silently
+        let end = str.length;
+        while (end > 0 && str.charAt(end - 1) === '=') {
+            --end;
+        }
+        const unpadded = str.substring(0, end);
+        if (str.length - end > 2 || unpadded.includes('=') || (unpadded.length === 0 && str.length > 0)) {
+            throw new Error('invalid padding');
+        }
+        if (unpadded.length % 4 === 1) {
+            throw new Error('invalid length');
+        }
+        for (const c of unpadded) {
+            if (d.indexOf(c) === -1) {
+                throw new Error(`invalid character '${c}'`);
             }
-            --nbytes;
         }
+        const nbytes = Math.floor(unpadded.length * 0.75);
         const view = new Uint8Array(nbytes);
 
         let vi = 0;
@@ -61,10 +120,10 @@ class Base64 {
         //one or two: writing them anyway would rely on typed arrays dropping writes
         //past their length
         while (vi < nbytes) {
-            const v1 = d.indexOf(str.charAt(si++));
-            const v2 = d.indexOf(str.charAt(si++));
-            const v3 = d.indexOf(str.charAt(si++));
-            const v4 = d.indexOf(str.charAt(si++));
+            const v1 = d.indexOf(unpadded.charAt(si++));
+            const v2 = d.indexOf(unpadded.charAt(si++));
+            const v3 = d.indexOf(unpadded.charAt(si++));
+            const v4 = d.indexOf(unpadded.charAt(si++));
             view[vi++] = (v1 << 2) | (v2 >> 4);
             if (vi === nbytes) {
                 break;
@@ -83,11 +142,21 @@ class Base64 {
 Base64.STANDARD = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/';
 Base64.URL_SAFE = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_';
 
+/**
+ * Hex encoding and decoding over byte sequences, lowercase by default.
+ */
 class Hex {
+    /**
+     * @param {string} hex
+     * @returns {Uint8Array}
+     */
     static decode(hex) {
         if (hex.length % 2 !== 0) {
             throw new Error('invalid length');
         }
+        if (!/^[0-9a-fA-F]*$/.test(hex)) {
+            throw new Error('invalid character');
+        }
         const lenInBytes = hex.length / 2;
         return new Uint8Array(lenInBytes).map((e, i) => {
             const offset = i * 2;
@@ -95,6 +164,11 @@ class Hex {
             return parseInt(octet, 16);
         });
     }
+    /**
+     * @param {Iterable<number>} bytes
+     * @param {boolean} [upper]
+     * @returns {string}
+     */
     static encode(bytes, upper) {
         return Array.from(bytes)
             .map((b) => b.toString(16))
@@ -104,6 +178,7 @@ class Hex {
     }
 }
 
+/** A parsed `Content-Type`: the type and subtype without the parameters, so a comparison is not defeated by a charset. */
 class MediaType {
     #type;
     #subtype;
@@ -121,7 +196,7 @@ class MediaType {
         return this.#subtype;
     }
     /**
-     *
+     * Parses a Content-Type header value into its type/subtype pair, dropping any parameter.
      * @param {string|null|undefined} v
      * @returns
      */
@@ -130,8 +205,11 @@ class MediaType {
             return new MediaType('unknown', 'unknown');
         }
         const [prefix, _] = v.split(';');
-        const [ptype, psubtype] = prefix.trim().split('/');
-        return new MediaType(ptype.toLowerCase(), psubtype?.toLowerCase());
+        const [ptype, psubtype] = prefix.trim().toLowerCase().split('/');
+        if (!ptype || !psubtype) {
+            return new MediaType('unknown', 'unknown');
+        }
+        return new MediaType(ptype, psubtype);
     }
 }
 
@@ -143,6 +221,11 @@ class MediaType {
  * @property {(url: URL, init: RequestInit|undefined, chain: HttpInterceptorChain) => Promise<Response>} intercept
  */
 
+/**
+ * A Failure from an http exchange, carrying the status that was served. Status
+ * 0 means no response was served at all: the transport failed, or a body the
+ * server did send could not be read.
+ */
 class HttpClientError extends Failure {
     /**
      * @param {string} message
@@ -155,29 +238,33 @@ class HttpClientError extends Failure {
         this.name = 'HttpClientError';
         this.status = status;
     }
+    /**
+     * Returns a copy whose problems' contexts have the prefix removed, keeping
+     * this error's status.
+     * @param {string} prefix
+     * @returns {HttpClientError}
+     */
     dropping(prefix) {
         return new HttpClientError(this.message, this.status, Failure.dropProblemsContext(this.problems, prefix), this);
     }
     /**
-     *
+     * One problem of the client's own making: the four the client mints are the
+     * same shape, and the server's arrive already shaped from the wire.
+     * @param {string} type
+     * @param {string} reason
+     */
+    static problem(type, reason) {
+        return { type, context: null, reason, details: null };
+    }
+    /**
+     * Creates a client failure carrying no status, wrapping the cause and its message.
      * @param {string} type
      * @param {any} cause
      * @returns
      */
     static of(type, cause) {
-        return new HttpClientError(
-            cause.message,
-            0,
-            [
-                {
-                    type,
-                    context: null,
-                    reason: cause.message,
-                    details: null,
-                },
-            ],
-            cause,
-        );
+        const reason = String(cause?.message ?? cause ?? 'unknown failure');
+        return new HttpClientError(reason, 0, [HttpClientError.problem(type, reason)], cause);
     }
     /**
      * Creates an HttpClientError from a Response.
@@ -187,55 +274,86 @@ class HttpClientError extends Failure {
     static async fromResponse(response) {
         switch (MediaType.parse(response.headers.get('Content-Type')).normalized) {
             case 'application/failures+json': {
-                const data = await response.json();
+                const data = await response.json().catch(() => HttpClientError.#unreadable);
+                if (data === HttpClientError.#unreadable) {
+                    return HttpClientError.#undecodable(response);
+                }
+                if (!Array.isArray(data)) {
+                    return HttpClientError.#undecodable(response, 'as a failures array');
+                }
                 const message = `${response.status} ${response.statusText}: ${data.length} failures`;
                 return new HttpClientError(message, response.status, data);
             }
             case 'application/problem+json': {
-                const data = await response.json();
+                const data = await response.json().catch(() => HttpClientError.#unreadable);
+                if (data === HttpClientError.#unreadable) {
+                    return HttpClientError.#undecodable(response);
+                }
+                if (typeof data !== 'object' || data === null || Array.isArray(data)) {
+                    return HttpClientError.#undecodable(response, 'as a problem object');
+                }
                 const message = `${response.status} ${response.statusText}: ${data.title} ${data.detail}`;
                 return new HttpClientError(
                     message,
                     response.status,
-                    data.problems || [
-                        {
-                            type: 'GENERIC_PROBLEM',
-                            context: null,
-                            reason: message,
-                            details: null,
-                        },
-                    ],
+                    data.problems || [HttpClientError.problem('GENERIC_PROBLEM', message)],
                 );
             }
             default: {
-                const text = await response.text();
-                const message = `${response.status} ${response.statusText}: ${text}`;
-                return new HttpClientError(message, response.status, [
-                    {
-                        type: 'GENERIC_PROBLEM',
-                        context: null,
-                        reason: message,
-                        details: null,
-                    },
-                ]);
+                return HttpClientError.#generic(response);
             }
         }
     }
+    /** marks a body whose json() rejected, telling it apart from a body decoding to json null */
+    static #unreadable = Symbol('unreadable body');
+    /**
+     * A json body that failed to decode, or that decoded to something other than
+     * the declared contract, has consumed its stream: there is no text left to
+     * embed, the status, the declared media type and the shape are the report.
+     * @param {Response} response
+     * @param {string} [as] - what the body does not decode as
+     */
+    static #undecodable(response, as = 'as json') {
+        const mediaType = MediaType.parse(response.headers.get('Content-Type')).normalized;
+        const message = `${response.status} ${response.statusText}: the ${mediaType} body does not decode ${as}`;
+        return new HttpClientError(message, response.status, [HttpClientError.problem('GENERIC_PROBLEM', message)]);
+    }
+    static async #generic(response) {
+        //a body that cannot be read (the connection cut mid-body) must not
+        //masquerade as a connection problem: the response was served, its
+        //status is the report
+        const text = await response.text().catch(() => null);
+        const message =
+            text === null
+                ? `${response.status} ${response.statusText}: the body could not be read`
+                : `${response.status} ${response.statusText}: ${text}`;
+        return new HttpClientError(message, response.status, [HttpClientError.problem('GENERIC_PROBLEM', message)]);
+    }
 }
 
+const metaContent = (name) =>
+    globalThis.document?.querySelector(`meta[name="${name}"]`)?.getAttribute('content') ?? undefined;
+
 /**
  * @implements {HttpInterceptor}
  */
+/**
+ * Sends the csrf header named by the page's `_csrf_header` meta, with the token
+ * from `_csrf`. Both are read per request, so metas replaced after the client
+ * was built are honoured, and the header is sent to the page's own origin only.
+ */
 class CsrfTokenInterceptor {
-    #k;
-    #v;
-    constructor() {
-        this.#k = document.querySelector("meta[name='_csrf_header']")?.getAttribute('content');
-        this.#v = document.querySelector("meta[name='_csrf']")?.getAttribute('content');
-    }
     async intercept(url, request, chain) {
-        if (this.#k && this.#v) {
-            request.headers.set(this.#k, this.#v);
+        //the token is the page's own: it travels to the page's origin only, and it
+        //is read at request time, so metas landed after the client was built (a
+        //login flow) are honored without a rebuild
+        if (url.origin !== (globalThis.window?.location?.origin ?? url.origin)) {
+            return await chain.proceed(url, request);
+        }
+        const csrfHeader = metaContent('_csrf_header');
+        const csrfToken = metaContent('_csrf');
+        if (csrfHeader && csrfToken) {
+            request.headers.set(csrfHeader, csrfToken);
         }
         return await chain.proceed(url, request);
     }
@@ -243,6 +361,11 @@ class CsrfTokenInterceptor {
 /**
  * @implements {HttpInterceptor}
  */
+/**
+ * Navigates to a login url when a response comes back 401. The promise it
+ * returns never settles, so callers keep waiting while the page unloads
+ * instead of showing a failure nobody will be present to read.
+ */
 class RedirectOnUnauthorizedInterceptor {
     #redirectUri;
     /**
@@ -255,12 +378,17 @@ class RedirectOnUnauthorizedInterceptor {
         const response = await chain.proceed(url, request);
         if (response.status === 401) {
             window.location.href = this.#redirectUri;
+            //the page is navigating away: a promise that never settles keeps the
+            //callers' spinners up instead of flashing a failure nobody will read.
+            //Where the navigation is blocked (a beforeunload gate), they stay
+            //pending until the page actually leaves
             return new Promise(() => {});
         }
         return response;
     }
 }
 
+/** Collects the interceptors an HttpClient will run, in the order they are added. */
 class HttpClientBuilder {
     /**
      * @type {HttpInterceptor[]}
@@ -292,12 +420,21 @@ class HttpClientBuilder {
 /**
  * @implements {HttpInterceptor}
  */
+/** The last interceptor in every chain: the one that performs the request. */
 class HttpCall {
     async intercept(url, request, chain) {
-        return await fetch(url, request);
+        try {
+            return await fetch(url, request);
+        } catch (ex) {
+            //the one place a connection problem is a connection problem: the
+            //transport itself refused to deliver. Everything above this is code,
+            //and code that throws has a different story to tell
+            throw HttpClientError.of('CONNECTION_PROBLEM', ex);
+        }
     }
 }
 
+/** One request's position in the interceptor list: `proceed` runs the next interceptor, the last of which performs the request. */
 class HttpInterceptorChain {
     #interceptors;
     #current;
@@ -326,6 +463,11 @@ class HttpInterceptorChain {
     }
 }
 
+/**
+ * Performs http requests through a fixed list of interceptors. The verbs
+ * return a request builder; `exchange` is the lower-level entry that returns
+ * the Response itself without treating an error status as a failure.
+ */
 class HttpClient {
     #interceptors;
     /**
@@ -354,7 +496,8 @@ class HttpClient {
         const is = [...this.#interceptors, ...(interceptors || []), new HttpCall()];
         const chain = new HttpInterceptorChain(is, 0);
         const url = new URL(new Request(uri).url);
-        return await chain.proceed(url, options ?? {});
+        const request = { ...options, headers: new Headers(options?.headers) };
+        return await chain.proceed(url, request);
     }
     /**
      * Creates a request builder.
@@ -416,7 +559,7 @@ class HttpClient {
 }
 
 /**
- *
+ * Reads the response body as the given type, wrapping a failed read as an UNMARSHALING_PROBLEM.
  * @param {Response} response
  * @param {'text'|'json'|'blob'|'arrayBuffer'} type
  * @returns
@@ -449,6 +592,12 @@ const rawEntries = (source) => {
     return Object.entries(source);
 };
 
+/**
+ * One request under construction: method, url, parameters, headers and body,
+ * with a `fetch*` method per body type. Every configuration method returns the
+ * builder, and a `fetch*` rejects with an HttpClientError for any status
+ * outside 200-299.
+ */
 class HttpRequestBuilder {
     #client;
     #method;
@@ -458,6 +607,7 @@ class HttpRequestBuilder {
     #body;
     #options;
     #interceptors;
+    #fragment;
     /**
      * Creates an HttpRequestBuilder.
      * @param {HttpClient} client
@@ -466,16 +616,22 @@ class HttpRequestBuilder {
      * @returns {HttpRequestBuilder} the builder
      */
     static create(client, method, uri) {
-        const [baseUri, queryString = ''] = uri.split('?');
+        //'/a#frag?p=1' parses as hash '#frag?p=1' with an empty query, and a '?'
+        //may appear in a query itself: only the first of each splits
+        const hashIndex = uri.indexOf('#');
+        const fragment = hashIndex === -1 ? '' : uri.slice(hashIndex);
+        const withoutFragment = hashIndex === -1 ? uri : uri.slice(0, hashIndex);
+        const queryIndex = withoutFragment.indexOf('?');
         return new HttpRequestBuilder(
             client,
             method,
-            baseUri,
-            new URLSearchParams(queryString),
+            queryIndex === -1 ? withoutFragment : withoutFragment.slice(0, queryIndex),
+            new URLSearchParams(queryIndex === -1 ? '' : withoutFragment.slice(queryIndex + 1)),
             new Headers(),
             undefined,
             {},
             [],
+            fragment,
         );
     }
     /**
@@ -488,8 +644,9 @@ class HttpRequestBuilder {
      * @param {any} body
      * @param {Omit<RequestInit,"headers"|"method"|"body">} options
      * @param {HttpInterceptor[]} interceptors
+     * @param {string} [fragment]
      */
-    constructor(client, method, uri, params, headers, body, options, interceptors) {
+    constructor(client, method, uri, params, headers, body, options, interceptors, fragment = '') {
         this.#client = client;
         this.#method = method;
         this.#uri = uri;
@@ -498,6 +655,7 @@ class HttpRequestBuilder {
         this.#headers = headers;
         this.#options = options;
         this.#interceptors = interceptors;
+        this.#fragment = fragment;
     }
     /**
      * Add all passed headers to the request, overriding existing ones if that key already exists. Null and undefined values cause the key to be removed.
@@ -544,7 +702,7 @@ class HttpRequestBuilder {
         return this;
     }
     /**
-     * Adds a query parameter to the request, overriding it if it already exists. Empty vs, or a single null or undefined value cause the key to be removed.
+     * Adds a query parameter to the request, overriding it if it already exists. An empty list, or one carrying only null and undefined values, causes the key to be removed; nullish entries among real values are skipped.
      * @param {string} k
      * @param {...string} vs
      * @returns {HttpRequestBuilder} this builder
@@ -553,10 +711,11 @@ class HttpRequestBuilder {
         //overriding, as header, headers and params all do: pass every value in one
         //call to get a multi valued parameter
         this.#params.delete(k);
-        if (vs.length === 0 || vs[0] == null) {
+        const values = vs.filter((v) => v != null);
+        if (values.length === 0) {
             return this;
         }
-        for (const v of vs) {
+        for (const v of values) {
             this.#params.append(k, v);
         }
         return this;
@@ -579,8 +738,12 @@ class HttpRequestBuilder {
      * @returns {HttpRequestBuilder} this builder
      */
     json(body) {
+        if (body === undefined) {
+            return this;
+        }
+        const serialized = JSON.stringify(body);
         this.#headers.set('Content-Type', 'application/json');
-        this.#body = JSON.stringify(body);
+        this.#body = serialized;
         return this;
     }
     /**
@@ -618,7 +781,7 @@ class HttpRequestBuilder {
     }
     /**
      * Adds interceptors to the request.
-     * @param {[HttpInterceptor]} is - the interceptor to be regisered
+     * @param {[HttpInterceptor]} is - the interceptor to be registered
      * @returns {HttpRequestBuilder} this builder
      */
     interceptors(is) {
@@ -629,7 +792,7 @@ class HttpRequestBuilder {
     }
     /**
      * Adds an interceptor to the request.
-     * @param {HttpInterceptor} i - the interceptor to be regisered
+     * @param {HttpInterceptor} i - the interceptor to be registered
      * @returns {HttpRequestBuilder} this builder
      */
     interceptor(i) {
@@ -641,29 +804,22 @@ class HttpRequestBuilder {
      * @returns {Promise<Response>} the response
      */
     async exchange() {
-        const uri = this.#params.size ? `${this.#uri}?${this.#params}` : this.#uri;
+        const query = this.#params.size ? `?${this.#params}` : '';
         const opts = {
             ...this.#options,
             headers: this.#headers,
             method: this.#method,
             body: this.#body,
         };
-        return await this.#client.exchange(uri, opts, this.#interceptors);
+        return await this.#client.exchange(`${this.#uri}${query}${this.#fragment}`, opts, this.#interceptors);
     }
     /**
-     * Performs an HTTP exchange using the configured client request, and interceptos throwing a failure when response status is not in the 200-299 range.
+     * Performs an HTTP exchange using the configured client request, and interceptors throwing a failure when response status is not in the 200-299 range.
      * @returns {Promise<Response>} the response
      */
     async fetch() {
-        const uri = this.#params.size ? `${this.#uri}?${this.#params}` : this.#uri;
-        const opts = {
-            ...this.#options,
-            headers: this.#headers,
-            method: this.#method,
-            body: this.#body,
-        };
         try {
-            const response = await this.#client.exchange(uri, opts, this.#interceptors);
+            const response = await this.exchange();
             if (!response.ok) {
                 throw await HttpClientError.fromResponse(response);
             }
@@ -672,11 +828,15 @@ class HttpRequestBuilder {
             if (ex instanceof Failure) {
                 throw ex;
             }
-            throw HttpClientError.of('CONNECTION_PROBLEM', ex);
+            //fetch() answers a Failure whatever happened, so a caller reading
+            //`problems` never has to test the shape first. What reaches here is
+            //not the transport, which labels its own failure below the chain: it
+            //is a throw from the chain's own code, carried as the cause
+            throw HttpClientError.of('UNEXPECTED_PROBLEM', ex);
         }
     }
     /**
-     * Performs an HTTP exchange using the configured client request, and interceptos throwing a failure when response status is not in the 200-299 range.
+     * Performs an HTTP exchange using the configured client request, and interceptors throwing a failure when response status is not in the 200-299 range.
      * @returns {Promise<string>} the response body, as text
      */
     async fetchText() {
@@ -684,15 +844,20 @@ class HttpRequestBuilder {
         return await unmarshal(response, 'text');
     }
     /**
-     * Performs an HTTP exchange using the configured client request, and interceptos throwing a failure when response status is not in the 200-299 range.
+     * Performs an HTTP exchange using the configured client request, and interceptors throwing a failure when response status is not in the 200-299 range.
+     * A 204 yields null without reading the body; any other empty body is an unmarshaling failure.
      * @returns {Promise<any>} the response body, deserialized as JSON
      */
     async fetchJson() {
         const response = await this.fetch();
+        if (response.status === 204) {
+            //a 204 declares no content: there is no body to decode
+            return null;
+        }
         return await unmarshal(response, 'json');
     }
     /**
-     * Performs an HTTP exchange using the configured client request, and interceptos throwing a failure when response status is not in the 200-299 range.
+     * Performs an HTTP exchange using the configured client request, and interceptors throwing a failure when response status is not in the 200-299 range.
      * @returns {Promise<Blob>} the response body, as a Blob
      */
     async fetchBlob() {
@@ -700,7 +865,7 @@ class HttpRequestBuilder {
         return await unmarshal(response, 'blob');
     }
     /**
-     * Performs an HTTP exchange using the configured client request, and interceptos throwing a failure when response status is not in the 200-299 range.
+     * Performs an HTTP exchange using the configured client request, and interceptors throwing a failure when response status is not in the 200-299 range.
      * @returns {Promise<ArrayBuffer>} the response body, as an ArrayBuffer
      */
     async fetchArrayBuffer() {
@@ -709,6 +874,7 @@ class HttpRequestBuilder {
     }
 }
 
+/** Builds a multipart body: text fields, json parts, and single or repeated blobs. */
 class HttpMultipartRequestCustomizer {
     #formData;
     /**
@@ -770,5 +936,5 @@ class HttpMultipartRequestCustomizer {
     }
 }
 
-export { Base64, Failure, Hex, HttpClient, HttpClientError, MediaType };
+export { Base64, Failure, Hex, HttpClient, HttpClientBuilder, HttpClientError, HttpInterceptorChain, HttpMultipartRequestCustomizer, HttpRequestBuilder, MediaType };
 //# sourceMappingURL=httpc.mjs.map