@codingame/monaco-vscode-api 17.2.1 → 18.0.1

package/vscode/src/vs/base/common/date.js

@@ -1,5 +1,6 @@
 
 import { localize } from '../../nls.js';
+import { Lazy } from './lazy.js';
 import { LANGUAGE_DEFAULT } from './platform.js';
 
 const minute = 60;
@@ -238,36 +239,54 @@ function toLocalISOString(date) {
 }
 const safeIntl = {
     DateTimeFormat(locales, options) {
-        try {
-            return new Intl.DateTimeFormat(locales, options);
-        }
-        catch {
-            return new Intl.DateTimeFormat(undefined, options);
-        }
+        return ( new Lazy(() => {
+            try {
+                return new Intl.DateTimeFormat(locales, options);
+            }
+            catch {
+                return new Intl.DateTimeFormat(undefined, options);
+            }
+        }));
     },
     Collator(locales, options) {
-        try {
-            return new Intl.Collator(locales, options);
-        }
-        catch {
-            return new Intl.Collator(undefined, options);
-        }
+        return ( new Lazy(() => {
+            try {
+                return new Intl.Collator(locales, options);
+            }
+            catch {
+                return new Intl.Collator(undefined, options);
+            }
+        }));
     },
     Segmenter(locales, options) {
-        try {
-            return new Intl.Segmenter(locales, options);
-        }
-        catch {
-            return new Intl.Segmenter(undefined, options);
-        }
+        return ( new Lazy(() => {
+            try {
+                return new Intl.Segmenter(locales, options);
+            }
+            catch {
+                return new Intl.Segmenter(undefined, options);
+            }
+        }));
     },
     Locale(tag, options) {
-        try {
-            return new Intl.Locale(tag, options);
-        }
-        catch {
-            return new Intl.Locale(LANGUAGE_DEFAULT, options);
-        }
+        return ( new Lazy(() => {
+            try {
+                return new Intl.Locale(tag, options);
+            }
+            catch {
+                return new Intl.Locale(LANGUAGE_DEFAULT, options);
+            }
+        }));
+    },
+    NumberFormat(locales, options) {
+        return ( new Lazy(() => {
+            try {
+                return new Intl.NumberFormat(locales, options);
+            }
+            catch {
+                return new Intl.NumberFormat(undefined, options);
+            }
+        }));
     }
 };
 

package/vscode/src/vs/base/common/decorators.js

@@ -1,4 +1,5 @@
 
+import './errors.js';
 import './lifecycle.js';
 import './cancellation.js';
 

package/vscode/src/vs/base/common/errors.d.ts

@@ -50,10 +50,16 @@ export interface V8CallSite {
     isConstructor(): boolean;
     toString(): string;
 }
+export declare const canceledName = "Canceled";
 export declare function isCancellationError(error: any): boolean;
 export declare class CancellationError extends Error {
     constructor();
 }
+export declare class PendingMigrationError extends Error {
+    private static readonly _name;
+    static is(error: unknown): error is PendingMigrationError;
+    constructor(message: string);
+}
 export declare function canceled(): Error;
 export declare function illegalArgument(name?: string): Error;
 export declare function illegalState(name?: string): Error;

package/vscode/src/vs/base/common/errors.js

@@ -111,6 +111,16 @@ class CancellationError extends Error {
         this.name = this.message;
     }
 }
+class PendingMigrationError extends Error {
+    static { this._name = 'PendingMigrationError'; }
+    static is(error) {
+        return error instanceof PendingMigrationError || (error instanceof Error && error.name === PendingMigrationError._name);
+    }
+    constructor(message) {
+        super(message);
+        this.name = PendingMigrationError._name;
+    }
+}
 function canceled() {
     const error = ( new Error(canceledName));
     error.name = error.message;
@@ -190,4 +200,4 @@ class BugIndicatingError extends Error {
     }
 }
 
-export { BugIndicatingError, CancellationError, ErrorHandler, ErrorNoTelemetry, NotImplementedError, NotSupportedError, ReadonlyError, canceled, errorHandler, getErrorMessage, illegalArgument, illegalState, isCancellationError, onBugIndicatingError, onUnexpectedError, onUnexpectedExternalError, setUnexpectedErrorHandler, transformErrorForSerialization, transformErrorFromSerialization };
+export { BugIndicatingError, CancellationError, ErrorHandler, ErrorNoTelemetry, NotImplementedError, NotSupportedError, PendingMigrationError, ReadonlyError, canceled, canceledName, errorHandler, getErrorMessage, illegalArgument, illegalState, isCancellationError, onBugIndicatingError, onUnexpectedError, onUnexpectedExternalError, setUnexpectedErrorHandler, transformErrorForSerialization, transformErrorFromSerialization };

package/vscode/src/vs/base/common/event.d.ts

@@ -1,3 +1,4 @@
+import { CancelablePromise } from "./async.js";
 import { CancellationToken } from "./cancellation.js";
 import { DisposableStore, IDisposable } from "./lifecycle.js";
 import { LinkedList } from "./linkedList.js";
@@ -47,7 +48,7 @@ export declare namespace Event {
         removeEventListener(event: string | symbol, listener: Function): void;
     }
     function fromDOMEventEmitter<T>(emitter: DOMEventEmitter, eventName: string, map?: (...args: any[]) => T): Event<T>;
-    function toPromise<T>(event: Event<T>, disposables?: IDisposable[] | DisposableStore): Promise<T>;
+    function toPromise<T>(event: Event<T>, disposables?: IDisposable[] | DisposableStore): CancelablePromise<T>;
     function fromPromise<T>(promise: Promise<T>): Event<T | undefined>;
     function forward<T>(from: Event<T>, to: Emitter<T>): IDisposable;
     function runAndSubscribe<T>(event: Event<T>, handler: (e: T) => unknown, initial: T): IDisposable;

package/vscode/src/vs/base/common/event.js

@@ -120,12 +120,14 @@ var Event;
                         numDebouncedCalls = 0;
                     };
                     if (typeof delay === 'number') {
-                        clearTimeout(handle);
+                        if (handle) {
+                            clearTimeout(handle);
+                        }
                         handle = setTimeout(doFire, delay);
                     }
                     else {
                         if (handle === undefined) {
-                            handle = 0;
+                            handle = null;
                             queueMicrotask(doFire);
                         }
                     }
@@ -306,7 +308,13 @@ var Event;
     }
     Event.fromDOMEventEmitter = fromDOMEventEmitter;
     function toPromise(event, disposables) {
-        return ( new Promise(resolve => once(event)(resolve, null, disposables)));
+        let cancelRef;
+        const promise = ( new Promise((resolve, reject) => {
+            const listener = once(event)(resolve, null, disposables);
+            cancelRef = () => listener.dispose();
+        }));
+        promise.cancel = cancelRef;
+        return promise;
     }
     Event.toPromise = toPromise;
     function fromPromise(promise) {

package/vscode/src/vs/base/common/hash.d.ts

@@ -1,7 +1,7 @@
 import { VSBuffer } from "./buffer.js";
 type NotSyncHashable = ArrayBufferLike | ArrayBufferView;
 export declare function hash<T>(obj: T extends NotSyncHashable ? never : T): number;
-export declare function doHash(obj: any, hashVal: number): number;
+export declare function doHash(obj: unknown, hashVal: number): number;
 export declare function numberHash(val: number, initialHashVal: number): number;
 export declare function stringHash(s: string, hashVal: number): number;
 export declare const hashAsync: (input: string | ArrayBufferView | VSBuffer) => Promise<string>;

package/vscode/src/vs/base/common/hash.js

@@ -1,5 +1,5 @@
 
-import { VSBuffer } from './buffer.js';
+import { VSBuffer, encodeHex } from './buffer.js';
 import { isHighSurrogate, isLowSurrogate, computeCodePoint } from './strings.js';
 
 function hash(obj) {
@@ -81,7 +81,7 @@ function leftRotate(value, bits, totalBits = 32) {
 }
 function toHexString(bufferOrValue, bitsize = 32) {
     if (bufferOrValue instanceof ArrayBuffer) {
-        return ( Array.from(( new Uint8Array(bufferOrValue))).map(b => ( b.toString(16)).padStart(2, '0'))).join('');
+        return encodeHex(VSBuffer.wrap(( new Uint8Array(bufferOrValue))));
     }
     return ( (bufferOrValue >>> 0).toString(16)).padStart(bitsize / 4, '0');
 }

package/vscode/src/vs/base/common/hotReloadHelpers.js

@@ -1,8 +1,9 @@
 
 import { isHotReloadEnabled, registerHotReloadHandler } from './hotReload.js';
 import './observableInternal/index.js';
-import { observableSignalFromEvent, constObservable } from './observableInternal/utils.js';
-import { observableValue } from './observableInternal/base.js';
+import { constObservable } from './observableInternal/observables/constObservable.js';
+import { observableValue } from './observableInternal/observables/observableValue.js';
+import { observableSignalFromEvent } from './observableInternal/observables/observableSignalFromEvent.js';
 
 function readHotReloadableExport(value, reader) {
     observeHotReloadableExports([value], reader);

package/vscode/src/vs/base/common/htmlContent.d.ts

@@ -38,7 +38,7 @@ export declare class MarkdownString implements IMarkdownString {
     private _escape;
 }
 export declare function isEmptyMarkdownString(oneOrMany: IMarkdownString | IMarkdownString[] | null | undefined): boolean;
-export declare function isMarkdownString(thing: any): thing is IMarkdownString;
+export declare function isMarkdownString(thing: unknown): thing is IMarkdownString;
 export declare function markdownStringEqual(a: IMarkdownString, b: IMarkdownString): boolean;
 export declare function escapeMarkdownSyntaxTokens(text: string): string;
 export declare function appendEscapedMarkdownCodeBlockFence(code: string, langId: string): string;

package/vscode/src/vs/base/common/iterator.d.ts

@@ -1,5 +1,5 @@
 export declare namespace Iterable {
-    function is<T = any>(thing: any): thing is Iterable<T>;
+    function is<T = any>(thing: unknown): thing is Iterable<T>;
     function empty<T = any>(): Iterable<T>;
     function single<T>(element: T): Iterable<T>;
     function wrap<T>(iterableOrElement: Iterable<T> | T): Iterable<T>;
@@ -8,6 +8,7 @@ export declare namespace Iterable {
     function isEmpty<T>(iterable: Iterable<T> | undefined | null): boolean;
     function first<T>(iterable: Iterable<T>): T | undefined;
     function some<T>(iterable: Iterable<T>, predicate: (t: T, i: number) => unknown): boolean;
+    function every<T>(iterable: Iterable<T>, predicate: (t: T, i: number) => unknown): boolean;
     function find<T, R extends T>(iterable: Iterable<T>, predicate: (t: T) => t is R): R | undefined;
     function find<T>(iterable: Iterable<T>, predicate: (t: T) => boolean): T | undefined;
     function filter<T, R extends T>(iterable: Iterable<T>, predicate: (t: T) => t is R): Iterable<R>;
@@ -23,4 +24,5 @@ export declare namespace Iterable {
         Iterable<T>
     ];
     function asyncToArray<T>(iterable: AsyncIterable<T>): Promise<T[]>;
+    function asyncToArrayFlat<T>(iterable: AsyncIterable<T[]>): Promise<T[]>;
 }

package/vscode/src/vs/base/common/iterator.js

@@ -4,7 +4,7 @@ import { isIterable } from './types.js';
 var Iterable;
 (function (Iterable) {
     function is(thing) {
-        return thing && typeof thing === 'object' && typeof thing[Symbol.iterator] === 'function';
+        return !!thing && typeof thing === 'object' && typeof thing[Symbol.iterator] === 'function';
     }
     Iterable.is = is;
     const _empty = ( Object.freeze([]));
@@ -53,6 +53,16 @@ var Iterable;
         return false;
     }
     Iterable.some = some;
+    function every(iterable, predicate) {
+        let i = 0;
+        for (const element of iterable) {
+            if (!predicate(element, i++)) {
+                return false;
+            }
+        }
+        return true;
+    }
+    Iterable.every = every;
     function find(iterable, predicate) {
         for (const element of iterable) {
             if (predicate(element)) {
@@ -150,9 +160,17 @@ var Iterable;
         for await (const item of iterable) {
             result.push(item);
         }
-        return Promise.resolve(result);
+        return result;
     }
     Iterable.asyncToArray = asyncToArray;
+    async function asyncToArrayFlat(iterable) {
+        let result = [];
+        for await (const item of iterable) {
+            result = result.concat(item);
+        }
+        return result;
+    }
+    Iterable.asyncToArrayFlat = asyncToArrayFlat;
 })(Iterable || (Iterable = {}));
 
 export { Iterable };

package/vscode/src/vs/base/common/json.d.ts

@@ -108,4 +108,4 @@ export declare function getNodeValue(node: Node): any;
 export declare function contains(node: Node, offset: number, includeRightBound?: boolean): boolean;
 export declare function findNodeAtOffset(node: Node, offset: number, includeRightBound?: boolean): Node | undefined;
 export declare function visit(text: string, visitor: JSONVisitor, options?: ParseOptions): any;
-export declare function getNodeType(value: any): NodeType;
+export declare function getNodeType(value: unknown): NodeType;

package/vscode/src/vs/base/common/marshalling.d.ts

@@ -1,7 +1,7 @@
 import { VSBuffer } from "./buffer.js";
 import { URI, UriComponents } from "./uri.js";
 import { MarshalledId } from "./marshallingIds.js";
-export declare function stringify(obj: any): string;
+export declare function stringify(obj: unknown): string;
 export declare function parse(text: string): any;
 export interface MarshalledObject {
     $mid: MarshalledId;

package/vscode/src/vs/base/common/marshallingIds.d.ts

@@ -21,6 +21,5 @@ export declare enum MarshalledId {
     LanguageModelToolResult = 20,
     LanguageModelTextPart = 21,
     LanguageModelPromptTsxPart = 22,
-    LanguageModelDataPart = 23,
-    LanguageModelExtraDataPart = 24
+    LanguageModelDataPart = 23
 }

package/vscode/src/vs/base/common/marshallingIds.js

@@ -25,7 +25,6 @@ var MarshalledId;
     MarshalledId[MarshalledId["LanguageModelTextPart"] = 21] = "LanguageModelTextPart";
     MarshalledId[MarshalledId["LanguageModelPromptTsxPart"] = 22] = "LanguageModelPromptTsxPart";
     MarshalledId[MarshalledId["LanguageModelDataPart"] = 23] = "LanguageModelDataPart";
-    MarshalledId[MarshalledId["LanguageModelExtraDataPart"] = 24] = "LanguageModelExtraDataPart";
 })(MarshalledId || (MarshalledId = {}));
 
 export { MarshalledId };

package/vscode/src/vs/base/common/numbers.d.ts

@@ -21,5 +21,5 @@ export declare class SlidingWindowAverage {
     get value(): number;
 }
 export declare function isPointWithinTriangle(x: number, y: number, ax: number, ay: number, bx: number, by: number, cx: number, cy: number): boolean;
-export declare const randomInt: (max: number, min?: number) => number;
+export declare function randomInt(max: number, min?: number): number;
 export declare function randomChance(p: number): boolean;

package/vscode/src/vs/base/common/oauth.d.ts

@@ -0,0 +1,143 @@
+export declare const AUTH_PROTECTED_RESOURCE_METADATA_DISCOVERY_PATH = "/.well-known/oauth-protected-resource";
+export declare const AUTH_SERVER_METADATA_DISCOVERY_PATH = "/.well-known/oauth-authorization-server";
+export interface IAuthorizationProtectedResourceMetadata {
+    resource: string;
+    resource_name?: string;
+    authorization_servers?: string[];
+    jwks_uri?: string;
+    scopes_supported?: string[];
+    bearer_methods_supported?: string[];
+    resource_signing_alg_values_supported?: string[];
+    resource_encryption_alg_values_supported?: string[];
+    resource_encryption_enc_values_supported?: string[];
+    resource_documentation?: string;
+    resource_policy_uri?: string;
+    resource_tos_uri?: string;
+}
+export interface IAuthorizationServerMetadata {
+    issuer: string;
+    authorization_endpoint?: string;
+    token_endpoint?: string;
+    device_authorization_endpoint?: string;
+    jwks_uri?: string;
+    registration_endpoint?: string;
+    scopes_supported?: string[];
+    response_types_supported: string[];
+    response_modes_supported?: string[];
+    grant_types_supported?: string[];
+    token_endpoint_auth_methods_supported?: string[];
+    token_endpoint_auth_signing_alg_values_supported?: string[];
+    service_documentation?: string;
+    ui_locales_supported?: string[];
+    op_policy_uri?: string;
+    op_tos_uri?: string;
+    revocation_endpoint?: string;
+    revocation_endpoint_auth_methods_supported?: string[];
+    revocation_endpoint_auth_signing_alg_values_supported?: string[];
+    introspection_endpoint?: string;
+    introspection_endpoint_auth_methods_supported?: string[];
+    introspection_endpoint_auth_signing_alg_values_supported?: string[];
+    code_challenge_methods_supported?: string[];
+}
+export interface IRequiredAuthorizationServerMetadata extends IAuthorizationServerMetadata {
+    authorization_endpoint: string;
+    token_endpoint: string;
+    registration_endpoint: string;
+}
+export interface IAuthorizationDynamicClientRegistrationResponse {
+    client_id: string;
+    client_secret?: string;
+    client_secret_expires_at?: number;
+    client_name?: string;
+    client_uri?: string;
+    redirect_uris?: string[];
+    grant_types?: string[];
+    response_types?: string[];
+    token_endpoint_auth_method?: string;
+}
+export interface IAuthorizationAuthorizeResponse {
+    code: string;
+    state: string;
+}
+export interface IAuthorizationAuthorizeErrorResponse {
+    error: string;
+    error_description?: string;
+    error_uri?: string;
+    state: string;
+}
+export interface IAuthorizationTokenResponse {
+    access_token: string;
+    token_type: string;
+    expires_in?: number;
+    refresh_token?: string;
+    scope?: string;
+    id_token?: string;
+}
+export interface IAuthorizationTokenErrorResponse {
+    error: string;
+    error_description?: string;
+    error_uri?: string;
+}
+export interface IAuthorizationDeviceResponse {
+    device_code: string;
+    user_code: string;
+    verification_uri: string;
+    verification_uri_complete?: string;
+    expires_in: number;
+    interval?: number;
+}
+export interface IAuthorizationDeviceTokenErrorResponse {
+    error: "invalid_request" | "invalid_client" | "invalid_grant" | "unauthorized_client" | "unsupported_grant_type" | "invalid_scope" | "authorization_pending" | "slow_down" | "access_denied" | "expired_token" | string;
+    error_description?: string;
+    error_uri?: string;
+}
+export interface IAuthorizationJWTClaims {
+    jti: string;
+    sub: string;
+    iss: string;
+    aud?: string | string[];
+    exp?: number;
+    nbf?: number;
+    iat?: number;
+    azp?: string;
+    scope?: string;
+    name?: string;
+    given_name?: string;
+    family_name?: string;
+    middle_name?: string;
+    preferred_username?: string;
+    email?: string;
+    email_verified?: boolean;
+    picture?: string;
+    auth_time?: number;
+    acr?: string;
+    amr?: string[];
+    sid?: string;
+    address?: {
+        formatted?: string;
+        street_address?: string;
+        locality?: string;
+        region?: string;
+        postal_code?: string;
+        country?: string;
+    };
+    groups?: string[];
+    roles?: string[];
+    [key: string]: unknown;
+}
+export declare function isAuthorizationProtectedResourceMetadata(obj: unknown): obj is IAuthorizationProtectedResourceMetadata;
+export declare function isAuthorizationServerMetadata(obj: unknown): obj is IAuthorizationServerMetadata;
+export declare function isAuthorizationDynamicClientRegistrationResponse(obj: unknown): obj is IAuthorizationDynamicClientRegistrationResponse;
+export declare function isAuthorizationAuthorizeResponse(obj: unknown): obj is IAuthorizationAuthorizeResponse;
+export declare function isAuthorizationTokenResponse(obj: unknown): obj is IAuthorizationTokenResponse;
+export declare function isAuthorizationDeviceResponse(obj: unknown): obj is IAuthorizationDeviceResponse;
+export declare function isAuthorizationDeviceTokenErrorResponse(obj: unknown): obj is IAuthorizationDeviceTokenErrorResponse;
+export declare function getDefaultMetadataForUrl(authorizationServer: URL): IRequiredAuthorizationServerMetadata & IRequiredAuthorizationServerMetadata;
+export declare function getMetadataWithDefaultValues(metadata: IAuthorizationServerMetadata): IAuthorizationServerMetadata & IRequiredAuthorizationServerMetadata;
+export declare const DEFAULT_AUTH_FLOW_PORT = 33418;
+export declare function fetchDynamicRegistration(registrationEndpoint: string, clientName: string): Promise<IAuthorizationDynamicClientRegistrationResponse>;
+export declare function parseWWWAuthenticateHeader(wwwAuthenticateHeaderValue: string): {
+    scheme: string;
+    params: Record<string, string>;
+};
+export declare function getClaimsFromJWT(token: string): IAuthorizationJWTClaims;

package/vscode/src/vs/base/common/oauth.js

@@ -0,0 +1,124 @@
+
+import { decodeBase64 } from './buffer.js';
+
+const WELL_KNOWN_ROUTE = '/.well-known';
+const AUTH_SERVER_METADATA_DISCOVERY_PATH = `${WELL_KNOWN_ROUTE}/oauth-authorization-server`;
+function isAuthorizationProtectedResourceMetadata(obj) {
+    if (typeof obj !== 'object' || obj === null) {
+        return false;
+    }
+    const metadata = obj;
+    return metadata.resource !== undefined;
+}
+function isAuthorizationServerMetadata(obj) {
+    if (typeof obj !== 'object' || obj === null) {
+        return false;
+    }
+    const metadata = obj;
+    return metadata.issuer !== undefined;
+}
+function isAuthorizationDynamicClientRegistrationResponse(obj) {
+    if (typeof obj !== 'object' || obj === null) {
+        return false;
+    }
+    const response = obj;
+    return response.client_id !== undefined;
+}
+function isAuthorizationTokenResponse(obj) {
+    if (typeof obj !== 'object' || obj === null) {
+        return false;
+    }
+    const response = obj;
+    return response.access_token !== undefined && response.token_type !== undefined;
+}
+function getDefaultMetadataForUrl(authorizationServer) {
+    return {
+        issuer: ( authorizationServer.toString()),
+        authorization_endpoint: ( ( new URL('/authorize', authorizationServer)).toString()),
+        token_endpoint: ( ( new URL('/token', authorizationServer)).toString()),
+        registration_endpoint: ( ( new URL('/register', authorizationServer)).toString()),
+        response_types_supported: ['code', 'id_token', 'id_token token'],
+    };
+}
+function getMetadataWithDefaultValues(metadata) {
+    const issuer = ( new URL(metadata.issuer));
+    return {
+        ...metadata,
+        authorization_endpoint: metadata.authorization_endpoint ?? ( ( new URL('/authorize', issuer)).toString()),
+        token_endpoint: metadata.token_endpoint ?? ( ( new URL('/token', issuer)).toString()),
+        registration_endpoint: metadata.registration_endpoint ?? ( ( new URL('/register', issuer)).toString()),
+    };
+}
+const DEFAULT_AUTH_FLOW_PORT = 33418;
+async function fetchDynamicRegistration(registrationEndpoint, clientName) {
+    const response = await fetch(registrationEndpoint, {
+        method: 'POST',
+        headers: {
+            'Content-Type': 'application/json'
+        },
+        body: JSON.stringify({
+            client_name: clientName,
+            client_uri: 'https://code.visualstudio.com',
+            grant_types: ['authorization_code', 'refresh_token', 'urn:ietf:params:oauth:grant-type:device_code'],
+            response_types: ['code'],
+            redirect_uris: [
+                'https://insiders.vscode.dev/redirect',
+                'https://vscode.dev/redirect',
+                'http://localhost/',
+                'http://127.0.0.1/',
+                `http://localhost:${DEFAULT_AUTH_FLOW_PORT}/`,
+                `http://127.0.0.1:${DEFAULT_AUTH_FLOW_PORT}/`
+            ],
+            token_endpoint_auth_method: 'none'
+        })
+    });
+    if (!response.ok) {
+        throw ( new Error(`Registration failed: ${response.statusText}`));
+    }
+    const registration = await response.json();
+    if (isAuthorizationDynamicClientRegistrationResponse(registration)) {
+        return registration;
+    }
+    throw ( new Error(
+        `Invalid authorization dynamic client registration response: ${JSON.stringify(registration)}`
+    ));
+}
+function parseWWWAuthenticateHeader(wwwAuthenticateHeaderValue) {
+    const parts = wwwAuthenticateHeaderValue.split(' ');
+    const scheme = parts[0];
+    const params = {};
+    if (parts.length > 1) {
+        const attributes = parts.slice(1).join(' ').split(',');
+        attributes.forEach(attr => {
+            const [key, value] = ( attr.split('=').map(s => s.trim().replace(/"/g, '')));
+            params[key] = value;
+        });
+    }
+    return { scheme, params };
+}
+function getClaimsFromJWT(token) {
+    const parts = token.split('.');
+    if (parts.length !== 3) {
+        throw ( new Error('Invalid JWT token format: token must have three parts separated by dots'));
+    }
+    const [header, payload, _signature] = parts;
+    try {
+        const decodedHeader = JSON.parse(( decodeBase64(header).toString()));
+        if (typeof decodedHeader !== 'object') {
+            throw ( new Error('Invalid JWT token format: header is not a JSON object'));
+        }
+        const decodedPayload = JSON.parse(( decodeBase64(payload).toString()));
+        if (typeof decodedPayload !== 'object') {
+            throw ( new Error('Invalid JWT token format: payload is not a JSON object'));
+        }
+        return decodedPayload;
+    }
+    catch (e) {
+        if (e instanceof Error) {
+            throw ( new Error(`Failed to parse JWT token: ${e.message}`));
+        }
+        throw ( new Error('Failed to parse JWT token'));
+    }
+}
+
+export { AUTH_SERVER_METADATA_DISCOVERY_PATH, DEFAULT_AUTH_FLOW_PORT, fetchDynamicRegistration, getClaimsFromJWT, getDefaultMetadataForUrl, getMetadataWithDefaultValues, isAuthorizationDynamicClientRegistrationResponse, isAuthorizationProtectedResourceMetadata, isAuthorizationServerMetadata, isAuthorizationTokenResponse, parseWWWAuthenticateHeader };