browser-debugger-cli 0.7.2 → 0.9.0

package/dist/telemetry/networkExtraInfo.d.ts

@@ -0,0 +1,106 @@
+/**
+ * Full request/response headers from CDP "ExtraInfo" events.
+ *
+ * `Network.requestWillBeSent` and `Network.responseReceived` omit headers the
+ * browser adds or filters for the page — `Cookie` on requests, `Set-Cookie` on
+ * responses. Chrome reports the raw headers separately in
+ * `requestWillBeSentExtraInfo` / `responseReceivedExtraInfo`, which may arrive
+ * before or after the main events (and occasionally after the request
+ * finished). This tracker buffers them and applies them to the right request.
+ */
+import type { NetworkRequest } from '../types.js';
+/**
+ * Matches ExtraInfo headers with captured requests.
+ */
+export declare class ExtraInfoTracker {
+    private readonly findActive;
+    private readonly pending;
+    private readonly recent;
+    /** Completed redirect hops per request id (their headers can arrive late) */
+    private readonly redirectHops;
+    /**
+     * @param findActive - Look up an in-flight request by CDP requestId
+     */
+    constructor(findActive: (requestId: string) => NetworkRequest | undefined);
+    /**
+     * Record full request headers (including `Cookie`).
+     *
+     * @param requestId - CDP request id
+     * @param headers - Raw request headers
+     */
+    onRequestExtraInfo(requestId: string, headers: Record<string, string>): void;
+    /**
+     * Record full response headers (including `Set-Cookie`).
+     *
+     * Applied immediately only when the request already has its response;
+     * otherwise kept until `applyResponse`, so the regular response headers do
+     * not overwrite them.
+     *
+     * @param requestId - CDP request id
+     * @param headers - Raw response headers
+     * @param statusCode - HTTP status the headers belong to
+     */
+    onResponseExtraInfo(requestId: string, headers: Record<string, string>, statusCode?: number): void;
+    /**
+     * Apply buffered request headers to a newly created request.
+     *
+     * @param requestId - CDP request id
+     * @param request - Request created from `requestWillBeSent`
+     */
+    applyRequest(requestId: string, request: NetworkRequest): void;
+    /**
+     * Apply buffered response headers after a response (or redirect response)
+     * was copied onto a request.
+     *
+     * @param requestId - CDP request id (a redirect hop has its own entry id)
+     * @param request - Request whose response was just recorded
+     */
+    applyResponse(requestId: string, request: NetworkRequest): void;
+    /**
+     * Remember a completed redirect hop: the headers of its 3xx response
+     * (with Set-Cookie) may arrive after the next hop has started.
+     *
+     * @param requestId - CDP request id shared by all hops
+     * @param hop - The completed hop
+     */
+    recordRedirectHop(requestId: string, hop: NetworkRequest): void;
+    /**
+     * Give raw response headers to the completed redirect hop they belong to:
+     * the hop with that status whose target is the headers' `Location`.
+     *
+     * @param requestId - CDP request id
+     * @param headers - Raw response headers
+     * @param statusCode - Status the headers belong to
+     * @returns True if a completed hop took the headers
+     */
+    private applyToRedirectHop;
+    /**
+     * Remember a finished request so late ExtraInfo events still reach it.
+     *
+     * @param requestId - CDP request id
+     * @param request - Finished request
+     */
+    complete(requestId: string, request: NetworkRequest): void;
+    /**
+     * Find an in-flight or recently finished request.
+     *
+     * @param requestId - CDP request id
+     * @returns Matching request, if any
+     */
+    private find;
+    /**
+     * Buffer headers until the matching request event arrives.
+     *
+     * @param requestId - CDP request id
+     * @param headers - Headers to merge into the buffer
+     */
+    private buffer;
+    /**
+     * Drop one kind of buffered headers.
+     *
+     * @param requestId - CDP request id
+     * @param key - Which headers were applied
+     */
+    private clear;
+}
+//# sourceMappingURL=networkExtraInfo.d.ts.map

package/dist/telemetry/networkExtraInfo.js

@@ -0,0 +1,241 @@
+/**
+ * Full request/response headers from CDP "ExtraInfo" events.
+ *
+ * `Network.requestWillBeSent` and `Network.responseReceived` omit headers the
+ * browser adds or filters for the page — `Cookie` on requests, `Set-Cookie` on
+ * responses. Chrome reports the raw headers separately in
+ * `requestWillBeSentExtraInfo` / `responseReceivedExtraInfo`, which may arrive
+ * before or after the main events (and occasionally after the request
+ * finished). This tracker buffers them and applies them to the right request.
+ */
+/** Recently finished requests kept for late ExtraInfo events. */
+const MAX_RECENT_REQUESTS = 500;
+/**
+ * Whether a status is an HTTP redirect.
+ *
+ * @param status - HTTP status
+ * @returns True for 3xx
+ */
+function isRedirect(status) {
+    return status !== undefined && status >= 300 && status < 400;
+}
+/**
+ * Whether headers reported for `headerStatus` belong to a response with `responseStatus`.
+ *
+ * Redirect hops share the CDP requestId; headers of a 3xx response must not
+ * land on the final response (or the other way round).
+ *
+ * @param headerStatus - Status reported with the ExtraInfo headers
+ * @param responseStatus - Status of the response being updated
+ * @returns True when they belong together
+ */
+function sameResponse(headerStatus, responseStatus) {
+    if (headerStatus === undefined || responseStatus === undefined)
+        return true;
+    return isRedirect(headerStatus) === isRedirect(responseStatus);
+}
+/**
+ * A header's value, whatever the case of its name.
+ *
+ * @param headers - Headers
+ * @param name - Lower-case header name
+ * @returns The value, if present
+ */
+function headerValue(headers, name) {
+    const key = Object.keys(headers).find((candidate) => candidate.toLowerCase() === name);
+    return key === undefined ? undefined : headers[key];
+}
+/**
+ * Whether a completed redirect hop went to a `Location` (relative to the hop).
+ *
+ * @param hop - Completed hop, with the URL it redirected to
+ * @param location - `Location` header value
+ * @returns True if they match
+ */
+function redirectsTo(hop, location) {
+    try {
+        return hop.redirectURL === new URL(location, hop.url).href;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Matches ExtraInfo headers with captured requests.
+ */
+export class ExtraInfoTracker {
+    findActive;
+    pending = new Map();
+    recent = new Map();
+    /** Completed redirect hops per request id (their headers can arrive late) */
+    redirectHops = new Map();
+    /**
+     * @param findActive - Look up an in-flight request by CDP requestId
+     */
+    constructor(findActive) {
+        this.findActive = findActive;
+    }
+    /**
+     * Record full request headers (including `Cookie`).
+     *
+     * @param requestId - CDP request id
+     * @param headers - Raw request headers
+     */
+    onRequestExtraInfo(requestId, headers) {
+        const request = this.find(requestId);
+        if (request)
+            request.requestHeaders = headers;
+        else
+            this.buffer(requestId, { requestHeaders: headers });
+    }
+    /**
+     * Record full response headers (including `Set-Cookie`).
+     *
+     * Applied immediately only when the request already has its response;
+     * otherwise kept until `applyResponse`, so the regular response headers do
+     * not overwrite them.
+     *
+     * @param requestId - CDP request id
+     * @param headers - Raw response headers
+     * @param statusCode - HTTP status the headers belong to
+     */
+    onResponseExtraInfo(requestId, headers, statusCode) {
+        if (this.applyToRedirectHop(requestId, headers, statusCode))
+            return;
+        const request = this.find(requestId);
+        if (request?.status === undefined) {
+            this.buffer(requestId, {
+                responseHeaders: headers,
+                ...(statusCode !== undefined && { responseStatus: statusCode }),
+            });
+        }
+        else if (sameResponse(statusCode, request.status)) {
+            request.responseHeaders = headers;
+        }
+    }
+    /**
+     * Apply buffered request headers to a newly created request.
+     *
+     * @param requestId - CDP request id
+     * @param request - Request created from `requestWillBeSent`
+     */
+    applyRequest(requestId, request) {
+        const pending = this.pending.get(requestId);
+        if (!pending?.requestHeaders)
+            return;
+        request.requestHeaders = pending.requestHeaders;
+        this.clear(requestId, 'requestHeaders');
+    }
+    /**
+     * Apply buffered response headers after a response (or redirect response)
+     * was copied onto a request.
+     *
+     * @param requestId - CDP request id (a redirect hop has its own entry id)
+     * @param request - Request whose response was just recorded
+     */
+    applyResponse(requestId, request) {
+        const pending = this.pending.get(requestId);
+        if (!pending?.responseHeaders)
+            return;
+        if (sameResponse(pending.responseStatus, request.status)) {
+            request.responseHeaders = pending.responseHeaders;
+        }
+        this.clear(requestId, 'responseHeaders');
+    }
+    /**
+     * Remember a completed redirect hop: the headers of its 3xx response
+     * (with Set-Cookie) may arrive after the next hop has started.
+     *
+     * @param requestId - CDP request id shared by all hops
+     * @param hop - The completed hop
+     */
+    recordRedirectHop(requestId, hop) {
+        const hops = this.redirectHops.get(requestId) ?? [];
+        this.redirectHops.delete(requestId);
+        this.redirectHops.set(requestId, [...hops, hop]);
+        if (this.redirectHops.size > MAX_RECENT_REQUESTS) {
+            const oldest = this.redirectHops.keys().next().value;
+            if (oldest !== undefined)
+                this.redirectHops.delete(oldest);
+        }
+    }
+    /**
+     * Give raw response headers to the completed redirect hop they belong to:
+     * the hop with that status whose target is the headers' `Location`.
+     *
+     * @param requestId - CDP request id
+     * @param headers - Raw response headers
+     * @param statusCode - Status the headers belong to
+     * @returns True if a completed hop took the headers
+     */
+    applyToRedirectHop(requestId, headers, statusCode) {
+        const location = headerValue(headers, 'location');
+        if (!isRedirect(statusCode) || !location)
+            return false;
+        const hop = this.redirectHops
+            .get(requestId)
+            ?.find((candidate) => candidate.status === statusCode && redirectsTo(candidate, location));
+        if (!hop)
+            return false;
+        hop.responseHeaders = headers;
+        return true;
+    }
+    /**
+     * Remember a finished request so late ExtraInfo events still reach it.
+     *
+     * @param requestId - CDP request id
+     * @param request - Finished request
+     */
+    complete(requestId, request) {
+        this.applyResponse(requestId, request);
+        this.pending.delete(requestId);
+        this.redirectHops.delete(requestId);
+        this.recent.delete(requestId);
+        this.recent.set(requestId, request);
+        if (this.recent.size > MAX_RECENT_REQUESTS) {
+            const oldest = this.recent.keys().next().value;
+            if (oldest !== undefined)
+                this.recent.delete(oldest);
+        }
+    }
+    /**
+     * Find an in-flight or recently finished request.
+     *
+     * @param requestId - CDP request id
+     * @returns Matching request, if any
+     */
+    find(requestId) {
+        return this.findActive(requestId) ?? this.recent.get(requestId);
+    }
+    /**
+     * Buffer headers until the matching request event arrives.
+     *
+     * @param requestId - CDP request id
+     * @param headers - Headers to merge into the buffer
+     */
+    buffer(requestId, headers) {
+        this.pending.set(requestId, { ...this.pending.get(requestId), ...headers });
+        if (this.pending.size > MAX_RECENT_REQUESTS) {
+            const oldest = this.pending.keys().next().value;
+            if (oldest !== undefined)
+                this.pending.delete(oldest);
+        }
+    }
+    /**
+     * Drop one kind of buffered headers.
+     *
+     * @param requestId - CDP request id
+     * @param key - Which headers were applied
+     */
+    clear(requestId, key) {
+        const pending = this.pending.get(requestId);
+        if (!pending)
+            return;
+        delete pending[key];
+        if (key === 'responseHeaders')
+            delete pending.responseStatus;
+        if (!pending.requestHeaders && !pending.responseHeaders)
+            this.pending.delete(requestId);
+    }
+}
+//# sourceMappingURL=networkExtraInfo.js.map

package/dist/telemetry/objectExpander.d.ts

@@ -6,11 +6,18 @@
  */
 import type { CDPConnection } from '../connection/cdp.js';
 import type { Protocol } from '../connection/typed-cdp.js';
-type RemoteObject = Protocol.Runtime.RemoteObject;
+/** Sends CDP commands to the session that owns the objects being expanded */
+export type CDPSender = Pick<CDPConnection, 'send'>;
 /**
- * Reset the failure counter (useful for testing).
+ * Bind CDP commands to one session: an attached target (iframe, worker) owns
+ * its objects and execution contexts.
+ *
+ * @param cdp - CDP connection
+ * @param sessionId - Session of the attached target, undefined for the page
+ * @returns Sender for that session
  */
-export declare function resetFailureCounter(): void;
+export declare function senderFor(cdp: CDPConnection, sessionId: string | undefined): CDPSender;
+type RemoteObject = Protocol.Runtime.RemoteObject;
 /**
  * Expand a RemoteObject to get nested property values.
  *
@@ -22,14 +29,16 @@ export declare function resetFailureCounter(): void;
  * @param depth - Current recursion depth
  * @returns Formatted string representation with expanded properties
  */
-export declare function expandRemoteObject(cdp: CDPConnection, arg: RemoteObject, depth?: number): Promise<string>;
+export declare function expandRemoteObject(cdp: CDPSender, arg: RemoteObject, depth?: number): Promise<string>;
 /**
  * Expand multiple RemoteObjects and format as console message text.
+ * Top-level strings are printed as they are (quotes only inside objects),
+ * as in Chrome's console.
  *
  * @param cdp - CDP connection for property fetching
  * @param args - Array of RemoteObjects to expand
  * @returns Formatted string with expanded objects
  */
-export declare function expandConsoleArgs(cdp: CDPConnection, args: RemoteObject[]): Promise<string>;
+export declare function expandConsoleArgs(cdp: CDPSender, args: RemoteObject[]): Promise<string>;
 export {};
 //# sourceMappingURL=objectExpander.d.ts.map

package/dist/telemetry/objectExpander.js

@@ -7,14 +7,19 @@
 import { OBJECT_EXPANSION_MAX_DEPTH, OBJECT_EXPANSION_MAX_PROPERTIES, OBJECT_EXPANSION_FAILURE_THRESHOLD, } from '../constants.js';
 import { createLogger } from '../ui/logging/index.js';
 import { isPrimitiveObject, hasSpecialDescription, getFallbackDescription, formatPrimitiveValue, } from './remoteObjectUtils.js';
-const log = createLogger('object-expander');
-let consecutiveFailures = 0;
 /**
- * Reset the failure counter (useful for testing).
+ * Bind CDP commands to one session: an attached target (iframe, worker) owns
+ * its objects and execution contexts.
+ *
+ * @param cdp - CDP connection
+ * @param sessionId - Session of the attached target, undefined for the page
+ * @returns Sender for that session
  */
-export function resetFailureCounter() {
-    consecutiveFailures = 0;
+export function senderFor(cdp, sessionId) {
+    return sessionId ? { send: (method, params) => cdp.send(method, params, sessionId) } : cdp;
 }
+const log = createLogger('object-expander');
+let consecutiveFailures = 0;
 /**
  * Record an expansion failure and log warning if threshold exceeded.
  */
@@ -153,13 +158,15 @@ export async function expandRemoteObject(cdp, arg, depth = 0) {
 }
 /**
  * Expand multiple RemoteObjects and format as console message text.
+ * Top-level strings are printed as they are (quotes only inside objects),
+ * as in Chrome's console.
  *
  * @param cdp - CDP connection for property fetching
  * @param args - Array of RemoteObjects to expand
  * @returns Formatted string with expanded objects
  */
 export async function expandConsoleArgs(cdp, args) {
-    const expanded = await Promise.all(args.map((arg) => expandRemoteObject(cdp, arg)));
+    const expanded = await Promise.all(args.map((arg) => typeof arg.value === 'string' ? Promise.resolve(arg.value) : expandRemoteObject(cdp, arg)));
     return expanded.join(' ');
 }
 //# sourceMappingURL=objectExpander.js.map

package/dist/telemetry/remoteObject.d.ts

@@ -27,11 +27,19 @@ type RemoteObject = Protocol.Runtime.RemoteObject;
  * ```
  */
 export declare function formatRemoteObject(arg: RemoteObject): string;
+/**
+ * Whether the first console argument is a format string with specifiers.
+ *
+ * @param args - Console arguments
+ * @returns True when `%s`-style substitution applies
+ */
+export declare function usesFormatSpecifiers(args: RemoteObject[]): boolean;
 /**
  * Format multiple RemoteObjects as console message text.
  *
- * Joins formatted arguments with spaces, similar to how console.log
- * displays multiple arguments.
+ * Applies format specifiers in a leading string argument (`%s`, `%d`, `%i`,
+ * `%f`, `%o`, `%O`, `%c` styles are dropped), then joins the remaining
+ * arguments with spaces, as Chrome's console does.
  *
  * @param args - Array of CDP RemoteObjects
  * @returns Joined formatted string

package/dist/telemetry/remoteObject.js

@@ -178,16 +178,73 @@ export function formatRemoteObject(arg) {
     }
     return getFallbackDescription(arg);
 }
+/** Console format specifiers (`%s`, `%d`, `%c`, ...; `%%` is a literal percent). */
+const FORMAT_SPECIFIER = /%([sdifoOc%])/g;
+/**
+ * Whether the first console argument is a format string with specifiers.
+ *
+ * @param args - Console arguments
+ * @returns True when `%s`-style substitution applies
+ */
+export function usesFormatSpecifiers(args) {
+    const [first] = args;
+    return (args.length > 1 &&
+        first?.type === 'string' &&
+        typeof first.value === 'string' &&
+        /%[sdifoOc%]/.test(first.value));
+}
+/**
+ * Number value of an argument for `%d` / `%i` / `%f`.
+ *
+ * @param arg - Console argument
+ * @returns Numeric value (NaN when not a number)
+ */
+function numericValue(arg) {
+    if (typeof arg.value === 'number')
+        return arg.value;
+    if (typeof arg.value === 'string')
+        return Number(arg.value);
+    return arg.unserializableValue !== undefined ? Number(arg.unserializableValue) : NaN;
+}
+/**
+ * Apply console format specifiers in the first argument, like Chrome does.
+ *
+ * @param format - First argument's string value
+ * @param rest - Remaining arguments; consumed ones are removed
+ * @returns Formatted first argument
+ */
+function applyFormatSpecifiers(format, rest) {
+    return format.replace(FORMAT_SPECIFIER, (match, spec) => {
+        if (spec === '%')
+            return '%';
+        const arg = rest.shift();
+        if (!arg)
+            return match;
+        if (spec === 'c')
+            return '';
+        if (spec === 'd' || spec === 'i')
+            return String(Math.trunc(numericValue(arg)));
+        if (spec === 'f')
+            return String(numericValue(arg));
+        return formatRemoteObject(arg);
+    });
+}
 /**
  * Format multiple RemoteObjects as console message text.
  *
- * Joins formatted arguments with spaces, similar to how console.log
- * displays multiple arguments.
+ * Applies format specifiers in a leading string argument (`%s`, `%d`, `%i`,
+ * `%f`, `%o`, `%O`, `%c` styles are dropped), then joins the remaining
+ * arguments with spaces, as Chrome's console does.
  *
  * @param args - Array of CDP RemoteObjects
  * @returns Joined formatted string
  */
 export function formatConsoleArgs(args) {
+    const [first, ...rest] = args;
+    if (usesFormatSpecifiers(args) && typeof first?.value === 'string') {
+        const head = applyFormatSpecifiers(first.value, rest);
+        return [head, ...rest.map(formatRemoteObject)].join(' ');
+    }
     return args.map(formatRemoteObject).join(' ');
 }
 //# sourceMappingURL=remoteObject.js.map

package/dist/telemetry/remoteObjectUtils.js

@@ -7,7 +7,22 @@
 /**
  * Subtypes that have meaningful description strings from CDP.
  */
-export const SPECIAL_DESCRIPTION_SUBTYPES = new Set(['date', 'regexp', 'error', 'promise']);
+export const SPECIAL_DESCRIPTION_SUBTYPES = new Set([
+    'date',
+    'regexp',
+    'error',
+    'promise',
+    'node',
+    'weakmap',
+    'weakset',
+    'weakref',
+    'typedarray',
+    'arraybuffer',
+    'dataview',
+    'proxy',
+    'generator',
+    'iterator',
+]);
 /**
  * Check if a RemoteObject is a primitive that can be formatted directly.
  */
@@ -44,11 +59,15 @@ export function formatPrimitiveValue(value) {
 }
 /**
  * Check if a preview property has unexpanded nested objects.
- * CDP shows nested objects as just "Object" without valuePreview.
+ * CDP shows nested objects as just "Object" (and arrays as "Array(n)")
+ * without valuePreview.
  */
 function hasUnexpandedNestedObjects(preview) {
     const props = preview.properties ?? [];
-    return props.some((p) => p.type === 'object' && !p.valuePreview && p.value === 'Object');
+    return props.some((p) => p.type === 'object' &&
+        !p.valuePreview &&
+        p.subtype !== 'null' &&
+        (p.value === 'Object' || (p.subtype === 'array' && p.value !== 'Array(0)')));
 }
 /**
  * Check if preview data is fully expanded (not truncated and no shallow nested objects).

package/dist/telemetry/requestKinds.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Which requests an action is about (pages, API calls, sockets) and which
+ * are static assets loaded along the way (stylesheets, scripts, fonts,
+ * images), by CDP resource type.
+ */
+/** Fields a request needs to be classified */
+interface ClassifiedRequest {
+    method?: string | undefined;
+    resourceType?: string | undefined;
+    status?: number | undefined;
+    failed?: true | undefined;
+}
+/**
+ * Whether a request is worth its own line after an action: one of the
+ * {@link ACTIVITY_RESOURCE_TYPES}, one of unknown type, any request that is
+ * not a GET (a `sendBeacon` POST typed `Other`), or an asset that failed (an
+ * HTTP error or no response).
+ *
+ * @param request - Request with its method and CDP resource type
+ * @returns False for assets fetched with GET that loaded normally
+ */
+export declare function isNotableRequest(request: ClassifiedRequest): boolean;
+/**
+ * Short names of the asset types among requests, e.g. `["css", "js", "images"]`
+ * (types without a short name are lowercased, after the known ones).
+ *
+ * @param requests - Asset requests
+ * @returns Distinct names, known types first
+ */
+export declare function assetTypeNames(requests: ClassifiedRequest[]): string[];
+export {};
+//# sourceMappingURL=requestKinds.d.ts.map

package/dist/telemetry/requestKinds.js

@@ -0,0 +1,61 @@
+/**
+ * Which requests an action is about (pages, API calls, sockets) and which
+ * are static assets loaded along the way (stylesheets, scripts, fonts,
+ * images), by CDP resource type.
+ */
+/**
+ * Resource types listed one by one after an action: pages, API calls,
+ * sockets, and the requests a page sends about itself (pings, beacons,
+ * preflights, CSP reports)
+ */
+const ACTIVITY_RESOURCE_TYPES = new Set([
+    'Document',
+    'XHR',
+    'Fetch',
+    'WebSocket',
+    'EventSource',
+    'Ping',
+    'Preflight',
+    'CSPViolationReport',
+]);
+/** Short names of asset types, in the order summaries list them */
+const ASSET_TYPE_NAMES = [
+    ['Stylesheet', 'css'],
+    ['Script', 'js'],
+    ['Font', 'fonts'],
+    ['Image', 'images'],
+    ['Media', 'media'],
+];
+/**
+ * Whether a request is worth its own line after an action: one of the
+ * {@link ACTIVITY_RESOURCE_TYPES}, one of unknown type, any request that is
+ * not a GET (a `sendBeacon` POST typed `Other`), or an asset that failed (an
+ * HTTP error or no response).
+ *
+ * @param request - Request with its method and CDP resource type
+ * @returns False for assets fetched with GET that loaded normally
+ */
+export function isNotableRequest(request) {
+    if (request.resourceType === undefined || ACTIVITY_RESOURCE_TYPES.has(request.resourceType)) {
+        return true;
+    }
+    if (request.method !== undefined && request.method.toUpperCase() !== 'GET')
+        return true;
+    return request.failed === true || (request.status ?? 0) >= 400;
+}
+/**
+ * Short names of the asset types among requests, e.g. `["css", "js", "images"]`
+ * (types without a short name are lowercased, after the known ones).
+ *
+ * @param requests - Asset requests
+ * @returns Distinct names, known types first
+ */
+export function assetTypeNames(requests) {
+    const types = new Set(requests.map((request) => request.resourceType ?? 'Other'));
+    const known = ASSET_TYPE_NAMES.filter(([type]) => types.has(type)).map(([, name]) => name);
+    const others = [...types]
+        .filter((type) => !ASSET_TYPE_NAMES.some(([known]) => known === type))
+        .map((type) => type.toLowerCase());
+    return [...known, ...others];
+}
+//# sourceMappingURL=requestKinds.js.map