@aragon/gov-ui-kit 1.26.0 → 1.27.0

package/dist/types/node_modules/.pnpm/ox@0.11.3_typescript@5.9.3_zod@3.25.76/node_modules/ox/core/internal/cursor.d.ts

@@ -0,0 +1,69 @@
+import type { Bytes } from '../Bytes.js';
+import * as Errors from '../Errors.js';
+/** @internal */
+export type Cursor = {
+    bytes: Bytes;
+    dataView: DataView;
+    position: number;
+    positionReadCount: Map<number, number>;
+    recursiveReadCount: number;
+    recursiveReadLimit: number;
+    remaining: number;
+    assertReadLimit(position?: number): void;
+    assertPosition(position: number): void;
+    decrementPosition(offset: number): void;
+    getReadCount(position?: number): number;
+    incrementPosition(offset: number): void;
+    inspectByte(position?: number): Bytes[number];
+    inspectBytes(length: number, position?: number): Bytes;
+    inspectUint8(position?: number): number;
+    inspectUint16(position?: number): number;
+    inspectUint24(position?: number): number;
+    inspectUint32(position?: number): number;
+    pushByte(byte: Bytes[number]): void;
+    pushBytes(bytes: Bytes): void;
+    pushUint8(value: number): void;
+    pushUint16(value: number): void;
+    pushUint24(value: number): void;
+    pushUint32(value: number): void;
+    readByte(): Bytes[number];
+    readBytes(length: number, size?: number): Bytes;
+    readUint8(): number;
+    readUint16(): number;
+    readUint24(): number;
+    readUint32(): number;
+    setPosition(position: number): () => void;
+    _touch(): void;
+};
+/** @internal */
+export declare function create(bytes: Bytes, { recursiveReadLimit }?: create.Config): Cursor;
+/** @internal */
+export declare namespace create {
+    type Config = {
+        recursiveReadLimit?: number | undefined;
+    };
+    type ErrorType = Errors.GlobalErrorType;
+}
+/** @internal */
+export declare class NegativeOffsetError extends Errors.BaseError {
+    readonly name = "Cursor.NegativeOffsetError";
+    constructor({ offset }: {
+        offset: number;
+    });
+}
+/** @internal */
+export declare class PositionOutOfBoundsError extends Errors.BaseError {
+    readonly name = "Cursor.PositionOutOfBoundsError";
+    constructor({ length, position }: {
+        length: number;
+        position: number;
+    });
+}
+/** @internal */
+export declare class RecursiveReadLimitExceededError extends Errors.BaseError {
+    readonly name = "Cursor.RecursiveReadLimitExceededError";
+    constructor({ count, limit }: {
+        count: number;
+        limit: number;
+    });
+}

package/dist/types/node_modules/.pnpm/ox@0.11.3_typescript@5.9.3_zod@3.25.76/node_modules/ox/core/internal/entropy.d.ts

@@ -0,0 +1,3 @@
+export declare let extraEntropy: boolean;
+/** @internal */
+export declare function setExtraEntropy(entropy: boolean): void;

package/dist/types/node_modules/.pnpm/ox@0.11.3_typescript@5.9.3_zod@3.25.76/node_modules/ox/core/internal/errors.d.ts

@@ -0,0 +1,6 @@
+/** @internal */
+export declare function getUrl(url: string): string;
+/** @internal */
+export declare function getVersion(): string;
+/** @internal */
+export declare function prettyPrint(args: unknown): string;

package/dist/types/node_modules/.pnpm/ox@0.11.3_typescript@5.9.3_zod@3.25.76/node_modules/ox/core/internal/hex.d.ts

@@ -0,0 +1,38 @@
+import type * as Errors from '../Errors.js';
+import * as Hex from '../Hex.js';
+/** @internal */
+export declare function assertSize(hex: Hex.Hex, size_: number): void;
+/** @internal */
+export declare namespace assertSize {
+    type ErrorType = Hex.size.ErrorType | Hex.SizeOverflowError | Errors.GlobalErrorType;
+}
+/** @internal */
+export declare function assertStartOffset(value: Hex.Hex, start?: number | undefined): void;
+export declare namespace assertStartOffset {
+    type ErrorType = Hex.SliceOffsetOutOfBoundsError | Hex.size.ErrorType | Errors.GlobalErrorType;
+}
+/** @internal */
+export declare function assertEndOffset(value: Hex.Hex, start?: number | undefined, end?: number | undefined): void;
+export declare namespace assertEndOffset {
+    type ErrorType = Hex.SliceOffsetOutOfBoundsError | Hex.size.ErrorType | Errors.GlobalErrorType;
+}
+/** @internal */
+export declare function pad(hex_: Hex.Hex, options?: pad.Options): `0x${string}`;
+/** @internal */
+export declare namespace pad {
+    type Options = {
+        dir?: 'left' | 'right' | undefined;
+        size?: number | undefined;
+    };
+    type ErrorType = Hex.SizeExceedsPaddingSizeError | Errors.GlobalErrorType;
+}
+/** @internal */
+export declare function trim(value: Hex.Hex, options?: trim.Options): trim.ReturnType;
+/** @internal */
+export declare namespace trim {
+    type Options = {
+        dir?: 'left' | 'right' | undefined;
+    };
+    type ReturnType = Hex.Hex;
+    type ErrorType = Errors.GlobalErrorType;
+}

package/dist/types/node_modules/.pnpm/ox@0.11.3_typescript@5.9.3_zod@3.25.76/node_modules/ox/core/internal/lru.d.ts

@@ -0,0 +1,12 @@
+/**
+ * @internal
+ *
+ * Map with a LRU (Least recently used) policy.
+ * @see https://en.wikipedia.org/wiki/Cache_replacement_policies#LRU
+ */
+export declare class LruMap<value = unknown> extends Map<string, value> {
+    maxSize: number;
+    constructor(size: number);
+    get(key: string): value | undefined;
+    set(key: string, value: value): this;
+}

package/dist/types/node_modules/.pnpm/ox@0.11.3_typescript@5.9.3_zod@3.25.76/node_modules/ox/core/internal/types.d.ts

@@ -0,0 +1,283 @@
+/** Combines members of an intersection into a readable type. */
+export type Compute<type> = {
+    [key in keyof type]: type[key];
+} & unknown;
+declare const symbol: unique symbol;
+/**
+ * Creates a branded type of `T` with the brand `U`.
+ *
+ * @example
+ * ```ts
+ * type Result = Branded<string, 'foo'>
+ * //   ^? type Result = string & { [symbol]: 'foo' }
+ * ```
+ */
+export type Branded<T, U> = T & {
+    [symbol]: U;
+};
+/**
+ * Filters out all members of `T` that are not `P`
+ *
+ * @example
+ * ```ts
+ * type Result = Filter<['a', 'b', 'c'], 'b'>
+ * //   ^? type Result = ['a', 'c']
+ * ```
+ *
+ * @internal
+ */
+export type Filter<T extends readonly unknown[], P, Acc extends readonly unknown[] = []> = T extends readonly [infer F, ...infer Rest extends readonly unknown[]] ? [F] extends [P] ? Filter<Rest, P, [...Acc, F]> : Filter<Rest, P, Acc> : readonly [...Acc];
+/**
+ * Checks if `T` can be narrowed further than `U`
+ *
+ * @example
+ * ```ts
+ * type Result = IsNarrowable<'foo', string>
+ * //   ^? true
+ * ```
+ */
+export type IsNarrowable<T, U> = IsNever<(T extends U ? true : false) & (U extends T ? false : true)> extends true ? false : true;
+/**
+ * Checks if `T` is `never`
+ *
+ * @example
+ * ```ts
+ * type Result = IsNever<never>
+ * //   ^? type Result = true
+ * ```
+ */
+export type IsNever<T> = [T] extends [never] ? true : false;
+/**
+ * Removes `readonly` from all properties of an object.
+ *
+ * @internal
+ */
+export type Mutable<type extends object> = {
+    -readonly [key in keyof type]: type[key];
+};
+/**
+ * Evaluates boolean "or" condition for `T` properties.
+ *
+ * * @example
+ * ```ts
+ * type Result = Or<[false, true, false]>
+ * //   ^? type Result = true
+ * ```
+ *
+ * @example
+ * ```ts
+ * type Result = Or<[false, false, false]>
+ * //   ^? type Result = false
+ * ```
+ *
+ * @internal
+ */
+export type Or<T extends readonly unknown[]> = T extends readonly [
+    infer Head,
+    ...infer Tail
+] ? Head extends true ? true : Or<Tail> : false;
+/**
+ * Checks if `T` is `undefined`
+ *
+ * @example
+ * ```ts
+ * type Result = IsUndefined<undefined>
+ * //   ^? type Result = true
+ * ```
+ *
+ * @internal
+ */
+export type IsUndefined<T> = [undefined] extends [T] ? true : false;
+/**
+ * Checks if type `T` is the `unknown` type.
+ *
+ * @internal
+ */
+export type IsUnknown<T> = unknown extends T ? [T] extends [null] ? false : true : false;
+/** @internal */
+export type MaybePromise<T> = T | Promise<T>;
+/**
+ * Makes attributes on the type T required if required is true.
+ *
+ * @example
+ * ```ts
+ * MaybeRequired<{ a: string, b?: number }, true>
+ * // { a: string, b: number }
+ *
+ * MaybeRequired<{ a: string, b?: number }, false>
+ * // { a: string, b?: number }
+ * ```
+ *
+ * @internal
+ */
+export type MaybeRequired<T, required extends boolean> = required extends true ? ExactRequired<T> : T;
+/**
+ * Assigns the properties of U onto T.
+ *
+ * @example
+ * ```ts
+ * Assign<{ a: string, b: number }, { a: undefined, c: boolean }>
+ * // { a: undefined, b: number, c: boolean }
+ * ```
+ *
+ * @internal
+ */
+export type Assign<T, U> = Assign_inner<T, U> & U;
+/** @internal */
+export type Assign_inner<T, U> = {
+    [K in keyof T as K extends keyof U ? U[K] extends void ? never : K : K]: K extends keyof U ? U[K] : T[K];
+};
+/**
+ * Constructs a type by excluding `undefined` from `T`.
+ *
+ * @example
+ * ```ts
+ * NoUndefined<string | undefined>
+ * // string
+ * ```
+ *
+ * @internal
+ */
+export type NoUndefined<T> = T extends undefined ? never : T;
+/**
+ * Strict version of built-in Omit type
+ *
+ * @internal
+ */
+export type Omit<type, keys extends keyof type> = Pick<type, Exclude<keyof type, keys>>;
+/**
+ * Creates a type that is a partial of T, but with the required keys K.
+ *
+ * @example
+ * ```ts
+ * PartialBy<{ a: string, b: number }, 'a'>
+ * // { a?: string, b: number }
+ * ```
+ *
+ * @internal
+ */
+export type PartialBy<T, K extends keyof T> = Omit<T, K> & ExactPartial<Pick<T, K>>;
+export type RecursiveArray<T> = T | readonly RecursiveArray<T>[];
+/**
+ * Creates a type that is T with the required keys K.
+ *
+ * @example
+ * ```ts
+ * RequiredBy<{ a?: string, b: number }, 'a'>
+ * // { a: string, b: number }
+ * ```
+ *
+ * @internal
+ */
+export type RequiredBy<T, K extends keyof T> = Omit<T, K> & ExactRequired<Pick<T, K>>;
+/**
+ * Returns truthy if `array` contains `value`.
+ *
+ * @example
+ * ```ts
+ * Some<[1, 2, 3], 2>
+ * // true
+ * ```
+ *
+ * @internal
+ */
+export type Some<array extends readonly unknown[], value> = array extends readonly [value, ...unknown[]] ? true : array extends readonly [unknown, ...infer rest] ? Some<rest, value> : false;
+/**
+ * Prints custom error message
+ *
+ * @param messages - Error message
+ * @returns Custom error message
+ *
+ * @example
+ * ```ts
+ * type Result = TypeErrorMessage<'Custom error message'>
+ * //   ^? type Result = ['Error: Custom error message']
+ * ```
+ */
+export type TypeErrorMessage<messages extends string | string[]> = messages extends string ? [
+    `Error: ${messages}`
+] : {
+    [key in keyof messages]: messages[key] extends infer message extends string ? `Error: ${message}` : never;
+};
+/** @internal */
+export type UnionToTuple<union, last = LastInUnion<union>> = [union] extends [never] ? [] : [...UnionToTuple<Exclude<union, last>>, last];
+/** @internal */
+export type LastInUnion<U> = UnionToIntersection<U extends unknown ? (x: U) => 0 : never> extends (x: infer l) => 0 ? l : never;
+/** @internal */
+export type UnionToIntersection<union> = (union extends unknown ? (arg: union) => 0 : never) extends (arg: infer i) => 0 ? i : never;
+/** @internal */
+export type IsUnion<union, union2 = union> = union extends union2 ? ([union2] extends [union] ? false : true) : never;
+/** @internal */
+export type MaybePartial<type, enabled extends boolean | undefined> = enabled extends true ? Compute<ExactPartial<type>> : type;
+export type ExactPartial<type> = {
+    [key in keyof type]?: type[key] | undefined;
+};
+/** @internal */
+export type ExactRequired<type> = {
+    [key in keyof type]-?: Exclude<type[key], undefined>;
+};
+export type OneOf<union extends object, fallback extends object | undefined = undefined, keys extends KeyofUnion<union> = KeyofUnion<union>> = union extends infer item ? Compute<item & {
+    [key in Exclude<keys, keyof item>]?: fallback extends object ? key extends keyof fallback ? fallback[key] : undefined : undefined;
+}> : never;
+/** @internal */
+export type KeyofUnion<type> = type extends type ? keyof type : never;
+/** @internal */
+export type Undefined<type> = {
+    [key in keyof type]?: undefined;
+};
+/**
+ * Loose version of {@link Omit}
+ * @internal
+ */
+export type LooseOmit<type, keys extends string> = Pick<type, Exclude<keyof type, keys>>;
+/** @internal */
+export type UnionCompute<type> = type extends object ? Compute<type> : type;
+/** @internal */
+export type UnionLooseOmit<type, keys extends string> = type extends any ? LooseOmit<type, keys> : never;
+/**
+ * Construct a type with the properties of union type T except for those in type K.
+ * @example
+ * ```ts
+ * type Result = UnionOmit<{ a: string, b: number } | { a: string, b: undefined, c: number }, 'a'>
+ * // { b: number } | { b: undefined, c: number }
+ * ```
+ *
+ * @internal
+ */
+export type UnionOmit<type, keys extends keyof type> = type extends any ? Omit<type, keys> : never;
+/**
+ * Construct a type with the properties of union type T except for those in type K.
+ * @example
+ * ```ts
+ * type Result = UnionOmit<{ a: string, b: number } | { a: string, b: undefined, c: number }, 'a'>
+ * // { b: number } | { b: undefined, c: number }
+ * ```
+ *
+ * @internal
+ */
+export type UnionPick<type, keys extends keyof type> = type extends any ? Pick<type, keys> : never;
+/**
+ * Creates a type that is a partial of T, but with the required keys K.
+ *
+ * @example
+ * ```ts
+ * PartialBy<{ a: string, b: number } | { a: string, b: undefined, c: number }, 'a'>
+ * // { a?: string, b: number } | { a?: string, b: undefined, c: number }
+ * ```
+ *
+ * @internal
+ */
+export type UnionPartialBy<T, K extends keyof T> = T extends any ? PartialBy<T, K> : never;
+/**
+ * Creates a type that is T with the required keys K.
+ *
+ * @example
+ * ```ts
+ * RequiredBy<{ a?: string, b: number } | { a?: string, c?: number }, 'a'>
+ * // { a: string, b: number } | { a: string, c?: number }
+ * ```
+ *
+ * @internal
+ */
+export type UnionRequiredBy<T, K extends keyof T> = T extends any ? RequiredBy<T, K> : never;
+export {};

package/dist/types/node_modules/.pnpm/ox@0.11.3_typescript@5.9.3_zod@3.25.76/node_modules/ox/core/internal/webauthn.d.ts

@@ -0,0 +1,130 @@
+import type * as Errors from '../Errors.js';
+import * as PublicKey from '../PublicKey.js';
+import { CredentialCreationFailedError } from '../WebAuthnP256.js';
+/** @internal */
+export type AttestationConveyancePreference = 'direct' | 'enterprise' | 'indirect' | 'none';
+/** @internal */
+export type AuthenticatorAttachment = 'cross-platform' | 'platform';
+/** @internal */
+export type AuthenticatorTransport = 'ble' | 'hybrid' | 'internal' | 'nfc' | 'usb';
+/** @internal */
+export type COSEAlgorithmIdentifier = number;
+/** @internal */
+export type CredentialMediationRequirement = 'conditional' | 'optional' | 'required' | 'silent';
+/** @internal */
+export type PublicKeyCredentialType = 'public-key';
+/** @internal */
+export type ResidentKeyRequirement = 'discouraged' | 'preferred' | 'required';
+/** @internal */
+export type UserVerificationRequirement = 'discouraged' | 'preferred' | 'required';
+/** @internal */
+export type LargeBlobSupport = {
+    support: 'required' | 'preferred';
+};
+/** @internal */
+export type BufferSource = ArrayBufferView | ArrayBuffer;
+/** @internal */
+export type PrfExtension = Record<'eval', Record<'first', Uint8Array>>;
+/** @internal */
+export interface AuthenticationExtensionsClientInputs {
+    appid?: string;
+    credProps?: boolean;
+    hmacCreateSecret?: boolean;
+    minPinLength?: boolean;
+    prf?: PrfExtension;
+    largeBlob?: LargeBlobSupport;
+}
+/** @internal */
+export interface AuthenticatorSelectionCriteria {
+    authenticatorAttachment?: AuthenticatorAttachment;
+    requireResidentKey?: boolean;
+    residentKey?: ResidentKeyRequirement;
+    userVerification?: UserVerificationRequirement;
+}
+/** @internal */
+export interface Credential {
+    readonly id: string;
+    readonly type: string;
+}
+/** @internal */
+export interface CredentialCreationOptions {
+    publicKey?: PublicKeyCredentialCreationOptions;
+    signal?: AbortSignal;
+}
+/** @internal */
+export interface CredentialRequestOptions {
+    mediation?: CredentialMediationRequirement;
+    publicKey?: PublicKeyCredentialRequestOptions;
+    signal?: AbortSignal;
+}
+/** @internal */
+export interface PublicKeyCredential extends Credential {
+    readonly authenticatorAttachment: string | null;
+    readonly rawId: ArrayBuffer;
+    readonly response: AuthenticatorResponse;
+    getClientExtensionResults(): AuthenticationExtensionsClientOutputs;
+}
+/** @internal */
+export interface PublicKeyCredentialCreationOptions {
+    attestation?: AttestationConveyancePreference;
+    authenticatorSelection?: AuthenticatorSelectionCriteria;
+    challenge: BufferSource;
+    excludeCredentials?: PublicKeyCredentialDescriptor[];
+    extensions?: AuthenticationExtensionsClientInputs;
+    pubKeyCredParams: PublicKeyCredentialParameters[];
+    rp: PublicKeyCredentialRpEntity;
+    timeout?: number;
+    user: PublicKeyCredentialUserEntity;
+}
+/** @internal */
+export interface PublicKeyCredentialDescriptor {
+    id: BufferSource;
+    transports?: AuthenticatorTransport[];
+    type: PublicKeyCredentialType;
+}
+/** @internal */
+export interface PublicKeyCredentialEntity {
+    name: string;
+}
+/** @internal */
+export interface PublicKeyCredentialParameters {
+    alg: COSEAlgorithmIdentifier;
+    type: PublicKeyCredentialType;
+}
+/** @internal */
+export interface PublicKeyCredentialRequestOptions {
+    allowCredentials?: PublicKeyCredentialDescriptor[];
+    challenge: BufferSource;
+    extensions?: AuthenticationExtensionsClientInputs;
+    rpId?: string;
+    timeout?: number;
+    userVerification?: UserVerificationRequirement;
+}
+/** @internal */
+export interface PublicKeyCredentialRpEntity extends PublicKeyCredentialEntity {
+    id?: string;
+}
+/** @internal */
+export interface PublicKeyCredentialUserEntity extends PublicKeyCredentialEntity {
+    displayName: string;
+    id: BufferSource;
+}
+/**
+ * Parses an ASN.1 signature into a r and s value.
+ *
+ * @internal
+ */
+export declare function parseAsn1Signature(bytes: Uint8Array): {
+    r: bigint;
+    s: bigint;
+};
+/**
+ * Parses a public key into x and y coordinates from the public key
+ * defined on the credential.
+ *
+ * @internal
+ */
+export declare function parseCredentialPublicKey(response: AuthenticatorAttestationResponse): Promise<PublicKey.PublicKey>;
+export declare namespace parseCredentialPublicKey {
+    type ErrorType = CredentialCreationFailedError | Errors.GlobalErrorType;
+}

package/dist/types/node_modules/.pnpm/ox@0.11.3_typescript@5.9.3_zod@3.25.76/node_modules/ox/core/version.d.ts

@@ -0,0 +1,2 @@
+/** @internal */
+export declare const version = "0.1.1";