@xfey/tutti 0.1.46 → 0.1.47

package/node_modules/@sinclair/typebox/build/esm/value/delta/delta.d.mts

@@ -1,32 +0,0 @@
-import type { Static } from '../../type/static/index.mjs';
-import { TypeBoxError } from '../../type/error/index.mjs';
-import { type TLiteral } from '../../type/literal/index.mjs';
-import { type TObject } from '../../type/object/index.mjs';
-import { type TString } from '../../type/string/index.mjs';
-import { type TUnknown } from '../../type/unknown/index.mjs';
-import { type TUnion } from '../../type/union/index.mjs';
-export type Insert = Static<typeof Insert>;
-export declare const Insert: TObject<{
-    type: TLiteral<'insert'>;
-    path: TString;
-    value: TUnknown;
-}>;
-export type Update = Static<typeof Update>;
-export declare const Update: TObject<{
-    type: TLiteral<'update'>;
-    path: TString;
-    value: TUnknown;
-}>;
-export type Delete = Static<typeof Delete>;
-export declare const Delete: TObject<{
-    type: TLiteral<'delete'>;
-    path: TString;
-}>;
-export type Edit = Static<typeof Edit>;
-export declare const Edit: TUnion<[typeof Insert, typeof Update, typeof Delete]>;
-export declare class ValueDiffError extends TypeBoxError {
-    readonly value: unknown;
-    constructor(value: unknown, message: string);
-}
-export declare function Diff(current: unknown, next: unknown): Edit[];
-export declare function Patch<T = any>(current: unknown, edits: Edit[]): T;

package/node_modules/@sinclair/typebox/build/esm/value/delta/delta.mjs

@@ -1,171 +0,0 @@
-import { HasPropertyKey, IsStandardObject, IsArray, IsTypedArray, IsValueType } from '../guard/index.mjs';
-import { ValuePointer } from '../pointer/index.mjs';
-import { Clone } from '../clone/index.mjs';
-import { Equal } from '../equal/equal.mjs';
-import { TypeBoxError } from '../../type/error/index.mjs';
-import { Literal } from '../../type/literal/index.mjs';
-import { Object } from '../../type/object/index.mjs';
-import { String } from '../../type/string/index.mjs';
-import { Unknown } from '../../type/unknown/index.mjs';
-import { Union } from '../../type/union/index.mjs';
-export const Insert = Object({
-    type: Literal('insert'),
-    path: String(),
-    value: Unknown(),
-});
-export const Update = Object({
-    type: Literal('update'),
-    path: String(),
-    value: Unknown(),
-});
-export const Delete = Object({
-    type: Literal('delete'),
-    path: String(),
-});
-export const Edit = Union([Insert, Update, Delete]);
-// ------------------------------------------------------------------
-// Errors
-// ------------------------------------------------------------------
-export class ValueDiffError extends TypeBoxError {
-    constructor(value, message) {
-        super(message);
-        this.value = value;
-    }
-}
-// ------------------------------------------------------------------
-// Command Factory
-// ------------------------------------------------------------------
-function CreateUpdate(path, value) {
-    return { type: 'update', path, value };
-}
-function CreateInsert(path, value) {
-    return { type: 'insert', path, value };
-}
-function CreateDelete(path) {
-    return { type: 'delete', path };
-}
-// ------------------------------------------------------------------
-// AssertDiffable
-// ------------------------------------------------------------------
-function AssertDiffable(value) {
-    if (globalThis.Object.getOwnPropertySymbols(value).length > 0)
-        throw new ValueDiffError(value, 'Cannot diff objects with symbols');
-}
-// ------------------------------------------------------------------
-// Diffing Generators
-// ------------------------------------------------------------------
-function* ObjectType(path, current, next) {
-    AssertDiffable(current);
-    AssertDiffable(next);
-    if (!IsStandardObject(next))
-        return yield CreateUpdate(path, next);
-    const currentKeys = globalThis.Object.getOwnPropertyNames(current);
-    const nextKeys = globalThis.Object.getOwnPropertyNames(next);
-    // ----------------------------------------------------------------
-    // inserts
-    // ----------------------------------------------------------------
-    for (const key of nextKeys) {
-        if (HasPropertyKey(current, key))
-            continue;
-        yield CreateInsert(`${path}/${key}`, next[key]);
-    }
-    // ----------------------------------------------------------------
-    // updates
-    // ----------------------------------------------------------------
-    for (const key of currentKeys) {
-        if (!HasPropertyKey(next, key))
-            continue;
-        if (Equal(current, next))
-            continue;
-        yield* Visit(`${path}/${key}`, current[key], next[key]);
-    }
-    // ----------------------------------------------------------------
-    // deletes
-    // ----------------------------------------------------------------
-    for (const key of currentKeys) {
-        if (HasPropertyKey(next, key))
-            continue;
-        yield CreateDelete(`${path}/${key}`);
-    }
-}
-function* ArrayType(path, current, next) {
-    if (!IsArray(next))
-        return yield CreateUpdate(path, next);
-    for (let i = 0; i < Math.min(current.length, next.length); i++) {
-        yield* Visit(`${path}/${i}`, current[i], next[i]);
-    }
-    for (let i = 0; i < next.length; i++) {
-        if (i < current.length)
-            continue;
-        yield CreateInsert(`${path}/${i}`, next[i]);
-    }
-    for (let i = current.length - 1; i >= 0; i--) {
-        if (i < next.length)
-            continue;
-        yield CreateDelete(`${path}/${i}`);
-    }
-}
-function* TypedArrayType(path, current, next) {
-    if (!IsTypedArray(next) || current.length !== next.length || globalThis.Object.getPrototypeOf(current).constructor.name !== globalThis.Object.getPrototypeOf(next).constructor.name)
-        return yield CreateUpdate(path, next);
-    for (let i = 0; i < Math.min(current.length, next.length); i++) {
-        yield* Visit(`${path}/${i}`, current[i], next[i]);
-    }
-}
-function* ValueType(path, current, next) {
-    if (current === next)
-        return;
-    yield CreateUpdate(path, next);
-}
-function* Visit(path, current, next) {
-    if (IsStandardObject(current))
-        return yield* ObjectType(path, current, next);
-    if (IsArray(current))
-        return yield* ArrayType(path, current, next);
-    if (IsTypedArray(current))
-        return yield* TypedArrayType(path, current, next);
-    if (IsValueType(current))
-        return yield* ValueType(path, current, next);
-    throw new ValueDiffError(current, 'Unable to diff value');
-}
-// ------------------------------------------------------------------
-// Diff
-// ------------------------------------------------------------------
-export function Diff(current, next) {
-    return [...Visit('', current, next)];
-}
-// ------------------------------------------------------------------
-// Patch
-// ------------------------------------------------------------------
-function IsRootUpdate(edits) {
-    return edits.length > 0 && edits[0].path === '' && edits[0].type === 'update';
-}
-function IsIdentity(edits) {
-    return edits.length === 0;
-}
-export function Patch(current, edits) {
-    if (IsRootUpdate(edits)) {
-        return Clone(edits[0].value);
-    }
-    if (IsIdentity(edits)) {
-        return Clone(current);
-    }
-    const clone = Clone(current);
-    for (const edit of edits) {
-        switch (edit.type) {
-            case 'insert': {
-                ValuePointer.Set(clone, edit.path, edit.value);
-                break;
-            }
-            case 'update': {
-                ValuePointer.Set(clone, edit.path, edit.value);
-                break;
-            }
-            case 'delete': {
-                ValuePointer.Delete(clone, edit.path);
-                break;
-            }
-        }
-    }
-    return clone;
-}

package/node_modules/@sinclair/typebox/build/esm/value/delta/index.d.mts

@@ -1 +0,0 @@
-export * from './delta.mjs';

package/node_modules/@sinclair/typebox/build/esm/value/delta/index.mjs

@@ -1 +0,0 @@
-export * from './delta.mjs';

package/node_modules/@sinclair/typebox/build/esm/value/deref/deref.d.mts

@@ -1,12 +0,0 @@
-import type { TSchema } from '../../type/schema/index.mjs';
-import type { TRef } from '../../type/ref/index.mjs';
-import type { TThis } from '../../type/recursive/index.mjs';
-import { TypeBoxError } from '../../type/error/index.mjs';
-export declare class TypeDereferenceError extends TypeBoxError {
-    readonly schema: TRef | TThis;
-    constructor(schema: TRef | TThis);
-}
-/** `[Internal]` Pushes a schema onto references if the schema has an $id and does not exist on references */
-export declare function Pushref(schema: TSchema, references: TSchema[]): TSchema[];
-/** `[Internal]` Dereferences a schema from the references array or throws if not found */
-export declare function Deref(schema: TSchema, references: TSchema[]): TSchema;

package/node_modules/@sinclair/typebox/build/esm/value/deref/deref.mjs

@@ -1,29 +0,0 @@
-import { TypeBoxError } from '../../type/error/index.mjs';
-import { Kind } from '../../type/symbols/index.mjs';
-import { IsString } from '../guard/guard.mjs';
-export class TypeDereferenceError extends TypeBoxError {
-    constructor(schema) {
-        super(`Unable to dereference schema with $id '${schema.$ref}'`);
-        this.schema = schema;
-    }
-}
-function Resolve(schema, references) {
-    const target = references.find((target) => target.$id === schema.$ref);
-    if (target === undefined)
-        throw new TypeDereferenceError(schema);
-    return Deref(target, references);
-}
-/** `[Internal]` Pushes a schema onto references if the schema has an $id and does not exist on references */
-export function Pushref(schema, references) {
-    if (!IsString(schema.$id) || references.some((target) => target.$id === schema.$id))
-        return references;
-    references.push(schema);
-    return references;
-}
-/** `[Internal]` Dereferences a schema from the references array or throws if not found */
-export function Deref(schema, references) {
-    // prettier-ignore
-    return (schema[Kind] === 'This' || schema[Kind] === 'Ref')
-        ? Resolve(schema, references)
-        : schema;
-}

package/node_modules/@sinclair/typebox/build/esm/value/deref/index.d.mts

@@ -1 +0,0 @@
-export * from './deref.mjs';

package/node_modules/@sinclair/typebox/build/esm/value/deref/index.mjs

@@ -1 +0,0 @@
-export * from './deref.mjs';

package/node_modules/@sinclair/typebox/build/esm/value/encode/encode.d.mts

@@ -1,6 +0,0 @@
-import type { TSchema } from '../../type/schema/index.mjs';
-import type { StaticEncode } from '../../type/static/index.mjs';
-/** Encodes a value or throws if error */
-export declare function Encode<T extends TSchema, Static = StaticEncode<T>, Result extends Static = Static>(schema: T, references: TSchema[], value: unknown): Result;
-/** Encodes a value or throws if error */
-export declare function Encode<T extends TSchema, Static = StaticEncode<T>, Result extends Static = Static>(schema: T, value: unknown): Result;

package/node_modules/@sinclair/typebox/build/esm/value/encode/encode.mjs

@@ -1,11 +0,0 @@
-import { HasTransform, TransformEncode, TransformEncodeCheckError } from '../transform/index.mjs';
-import { Check } from '../check/index.mjs';
-import { Errors } from '../../errors/index.mjs';
-/** Encodes a value or throws if error */
-export function Encode(...args) {
-    const [schema, references, value] = args.length === 3 ? [args[0], args[1], args[2]] : [args[0], [], args[1]];
-    const encoded = HasTransform(schema, references) ? TransformEncode(schema, references, value) : value;
-    if (!Check(schema, references, encoded))
-        throw new TransformEncodeCheckError(schema, encoded, Errors(schema, references, encoded).First());
-    return encoded;
-}

package/node_modules/@sinclair/typebox/build/esm/value/encode/index.d.mts

@@ -1 +0,0 @@
-export * from './encode.mjs';

package/node_modules/@sinclair/typebox/build/esm/value/encode/index.mjs

@@ -1 +0,0 @@
-export * from './encode.mjs';

package/node_modules/@sinclair/typebox/build/esm/value/equal/equal.d.mts

@@ -1,2 +0,0 @@
-/** Returns true if the left value deep-equals the right */
-export declare function Equal<T>(left: T, right: unknown): right is T;

package/node_modules/@sinclair/typebox/build/esm/value/equal/equal.mjs

@@ -1,46 +0,0 @@
-import { IsObject, IsDate, IsArray, IsTypedArray, IsValueType } from '../guard/index.mjs';
-// ------------------------------------------------------------------
-// Equality Checks
-// ------------------------------------------------------------------
-function ObjectType(left, right) {
-    if (!IsObject(right))
-        return false;
-    const leftKeys = [...Object.keys(left), ...Object.getOwnPropertySymbols(left)];
-    const rightKeys = [...Object.keys(right), ...Object.getOwnPropertySymbols(right)];
-    if (leftKeys.length !== rightKeys.length)
-        return false;
-    return leftKeys.every((key) => Equal(left[key], right[key]));
-}
-function DateType(left, right) {
-    return IsDate(right) && left.getTime() === right.getTime();
-}
-function ArrayType(left, right) {
-    if (!IsArray(right) || left.length !== right.length)
-        return false;
-    return left.every((value, index) => Equal(value, right[index]));
-}
-function TypedArrayType(left, right) {
-    if (!IsTypedArray(right) || left.length !== right.length || Object.getPrototypeOf(left).constructor.name !== Object.getPrototypeOf(right).constructor.name)
-        return false;
-    return left.every((value, index) => Equal(value, right[index]));
-}
-function ValueType(left, right) {
-    return left === right;
-}
-// ------------------------------------------------------------------
-// Equal
-// ------------------------------------------------------------------
-/** Returns true if the left value deep-equals the right */
-export function Equal(left, right) {
-    if (IsDate(left))
-        return DateType(left, right);
-    if (IsTypedArray(left))
-        return TypedArrayType(left, right);
-    if (IsArray(left))
-        return ArrayType(left, right);
-    if (IsObject(left))
-        return ObjectType(left, right);
-    if (IsValueType(left))
-        return ValueType(left, right);
-    throw new Error('ValueEquals: Unable to compare value');
-}

package/node_modules/@sinclair/typebox/build/esm/value/equal/index.d.mts

@@ -1 +0,0 @@
-export * from './equal.mjs';

package/node_modules/@sinclair/typebox/build/esm/value/equal/index.mjs

@@ -1 +0,0 @@
-export * from './equal.mjs';

package/node_modules/@sinclair/typebox/build/esm/value/guard/guard.d.mts

@@ -1,74 +0,0 @@
-export type ObjectType = Record<PropertyKey, unknown>;
-export type ArrayType = unknown[];
-export type ValueType = null | undefined | symbol | bigint | number | boolean | string;
-export type TypedArrayType = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
-/** Returns true if this value is an async iterator */
-export declare function IsAsyncIterator(value: unknown): value is AsyncIterableIterator<any>;
-/** Returns true if this value is an iterator */
-export declare function IsIterator(value: unknown): value is IterableIterator<any>;
-/** Returns true if this value is not an instance of a class */
-export declare function IsStandardObject(value: unknown): value is ObjectType;
-/** Returns true if this value is an instance of a class */
-export declare function IsInstanceObject(value: unknown): value is ObjectType;
-/** Returns true if this value is a Promise */
-export declare function IsPromise(value: unknown): value is Promise<unknown>;
-/** Returns true if this value is a Date */
-export declare function IsDate(value: unknown): value is Date;
-/** Returns true if this value is an instance of Map<K, T> */
-export declare function IsMap(value: unknown): value is Map<unknown, unknown>;
-/** Returns true if this value is an instance of Set<T> */
-export declare function IsSet(value: unknown): value is Set<unknown>;
-/** Returns true if this value is RegExp */
-export declare function IsRegExp(value: unknown): value is RegExp;
-/** Returns true if this value is a typed array */
-export declare function IsTypedArray(value: unknown): value is TypedArrayType;
-/** Returns true if the value is a Int8Array */
-export declare function IsInt8Array(value: unknown): value is Int8Array;
-/** Returns true if the value is a Uint8Array */
-export declare function IsUint8Array(value: unknown): value is Uint8Array;
-/** Returns true if the value is a Uint8ClampedArray */
-export declare function IsUint8ClampedArray(value: unknown): value is Uint8ClampedArray;
-/** Returns true if the value is a Int16Array */
-export declare function IsInt16Array(value: unknown): value is Int16Array;
-/** Returns true if the value is a Uint16Array */
-export declare function IsUint16Array(value: unknown): value is Uint16Array;
-/** Returns true if the value is a Int32Array */
-export declare function IsInt32Array(value: unknown): value is Int32Array;
-/** Returns true if the value is a Uint32Array */
-export declare function IsUint32Array(value: unknown): value is Uint32Array;
-/** Returns true if the value is a Float32Array */
-export declare function IsFloat32Array(value: unknown): value is Float32Array;
-/** Returns true if the value is a Float64Array */
-export declare function IsFloat64Array(value: unknown): value is Float64Array;
-/** Returns true if the value is a BigInt64Array */
-export declare function IsBigInt64Array(value: unknown): value is BigInt64Array;
-/** Returns true if the value is a BigUint64Array */
-export declare function IsBigUint64Array(value: unknown): value is BigUint64Array;
-/** Returns true if this value has this property key */
-export declare function HasPropertyKey<K extends PropertyKey>(value: Record<any, unknown>, key: K): value is Record<PropertyKey, unknown> & {
-    [_ in K]: unknown;
-};
-/** Returns true of this value is an object type */
-export declare function IsObject(value: unknown): value is ObjectType;
-/** Returns true if this value is an array, but not a typed array */
-export declare function IsArray(value: unknown): value is ArrayType;
-/** Returns true if this value is an undefined */
-export declare function IsUndefined(value: unknown): value is undefined;
-/** Returns true if this value is an null */
-export declare function IsNull(value: unknown): value is null;
-/** Returns true if this value is an boolean */
-export declare function IsBoolean(value: unknown): value is boolean;
-/** Returns true if this value is an number */
-export declare function IsNumber(value: unknown): value is number;
-/** Returns true if this value is an integer */
-export declare function IsInteger(value: unknown): value is number;
-/** Returns true if this value is bigint */
-export declare function IsBigInt(value: unknown): value is bigint;
-/** Returns true if this value is string */
-export declare function IsString(value: unknown): value is string;
-/** Returns true if this value is a function */
-export declare function IsFunction(value: unknown): value is Function;
-/** Returns true if this value is a symbol */
-export declare function IsSymbol(value: unknown): value is symbol;
-/** Returns true if this value is a value type such as number, string, boolean */
-export declare function IsValueType(value: unknown): value is ValueType;

package/node_modules/@sinclair/typebox/build/esm/value/guard/guard.mjs

@@ -1,158 +0,0 @@
-// --------------------------------------------------------------------------
-// Iterators
-// --------------------------------------------------------------------------
-/** Returns true if this value is an async iterator */
-export function IsAsyncIterator(value) {
-    return IsObject(value) && globalThis.Symbol.asyncIterator in value;
-}
-/** Returns true if this value is an iterator */
-export function IsIterator(value) {
-    return IsObject(value) && globalThis.Symbol.iterator in value;
-}
-// --------------------------------------------------------------------------
-// Object Instances
-// --------------------------------------------------------------------------
-/** Returns true if this value is not an instance of a class */
-export function IsStandardObject(value) {
-    return IsObject(value) && (globalThis.Object.getPrototypeOf(value) === Object.prototype || globalThis.Object.getPrototypeOf(value) === null);
-}
-/** Returns true if this value is an instance of a class */
-export function IsInstanceObject(value) {
-    return IsObject(value) && !IsArray(value) && IsFunction(value.constructor) && value.constructor.name !== 'Object';
-}
-// --------------------------------------------------------------------------
-// JavaScript
-// --------------------------------------------------------------------------
-/** Returns true if this value is a Promise */
-export function IsPromise(value) {
-    return value instanceof globalThis.Promise;
-}
-/** Returns true if this value is a Date */
-export function IsDate(value) {
-    return value instanceof Date && globalThis.Number.isFinite(value.getTime());
-}
-/** Returns true if this value is an instance of Map<K, T> */
-export function IsMap(value) {
-    return value instanceof globalThis.Map;
-}
-/** Returns true if this value is an instance of Set<T> */
-export function IsSet(value) {
-    return value instanceof globalThis.Set;
-}
-/** Returns true if this value is RegExp */
-export function IsRegExp(value) {
-    return value instanceof globalThis.RegExp;
-}
-/** Returns true if this value is a typed array */
-export function IsTypedArray(value) {
-    return globalThis.ArrayBuffer.isView(value);
-}
-/** Returns true if the value is a Int8Array */
-export function IsInt8Array(value) {
-    return value instanceof globalThis.Int8Array;
-}
-/** Returns true if the value is a Uint8Array */
-export function IsUint8Array(value) {
-    return value instanceof globalThis.Uint8Array;
-}
-/** Returns true if the value is a Uint8ClampedArray */
-export function IsUint8ClampedArray(value) {
-    return value instanceof globalThis.Uint8ClampedArray;
-}
-/** Returns true if the value is a Int16Array */
-export function IsInt16Array(value) {
-    return value instanceof globalThis.Int16Array;
-}
-/** Returns true if the value is a Uint16Array */
-export function IsUint16Array(value) {
-    return value instanceof globalThis.Uint16Array;
-}
-/** Returns true if the value is a Int32Array */
-export function IsInt32Array(value) {
-    return value instanceof globalThis.Int32Array;
-}
-/** Returns true if the value is a Uint32Array */
-export function IsUint32Array(value) {
-    return value instanceof globalThis.Uint32Array;
-}
-/** Returns true if the value is a Float32Array */
-export function IsFloat32Array(value) {
-    return value instanceof globalThis.Float32Array;
-}
-/** Returns true if the value is a Float64Array */
-export function IsFloat64Array(value) {
-    return value instanceof globalThis.Float64Array;
-}
-/** Returns true if the value is a BigInt64Array */
-export function IsBigInt64Array(value) {
-    return value instanceof globalThis.BigInt64Array;
-}
-/** Returns true if the value is a BigUint64Array */
-export function IsBigUint64Array(value) {
-    return value instanceof globalThis.BigUint64Array;
-}
-// --------------------------------------------------------------------------
-// PropertyKey
-// --------------------------------------------------------------------------
-/** Returns true if this value has this property key */
-export function HasPropertyKey(value, key) {
-    return key in value;
-}
-// --------------------------------------------------------------------------
-// Standard
-// --------------------------------------------------------------------------
-/** Returns true of this value is an object type */
-export function IsObject(value) {
-    return value !== null && typeof value === 'object';
-}
-/** Returns true if this value is an array, but not a typed array */
-export function IsArray(value) {
-    return globalThis.Array.isArray(value) && !globalThis.ArrayBuffer.isView(value);
-}
-/** Returns true if this value is an undefined */
-export function IsUndefined(value) {
-    return value === undefined;
-}
-/** Returns true if this value is an null */
-export function IsNull(value) {
-    return value === null;
-}
-/** Returns true if this value is an boolean */
-export function IsBoolean(value) {
-    return typeof value === 'boolean';
-}
-/** Returns true if this value is an number */
-export function IsNumber(value) {
-    return typeof value === 'number';
-}
-/** Returns true if this value is an integer */
-export function IsInteger(value) {
-    return globalThis.Number.isInteger(value);
-}
-/** Returns true if this value is bigint */
-export function IsBigInt(value) {
-    return typeof value === 'bigint';
-}
-/** Returns true if this value is string */
-export function IsString(value) {
-    return typeof value === 'string';
-}
-/** Returns true if this value is a function */
-export function IsFunction(value) {
-    return typeof value === 'function';
-}
-/** Returns true if this value is a symbol */
-export function IsSymbol(value) {
-    return typeof value === 'symbol';
-}
-/** Returns true if this value is a value type such as number, string, boolean */
-export function IsValueType(value) {
-    // prettier-ignore
-    return (IsBigInt(value) ||
-        IsBoolean(value) ||
-        IsNull(value) ||
-        IsNumber(value) ||
-        IsString(value) ||
-        IsSymbol(value) ||
-        IsUndefined(value));
-}

package/node_modules/@sinclair/typebox/build/esm/value/guard/index.d.mts

@@ -1 +0,0 @@
-export * from './guard.mjs';

package/node_modules/@sinclair/typebox/build/esm/value/guard/index.mjs

@@ -1 +0,0 @@
-export * from './guard.mjs';

package/node_modules/@sinclair/typebox/build/esm/value/hash/hash.d.mts

@@ -1,7 +0,0 @@
-import { TypeBoxError } from '../../type/error/index.mjs';
-export declare class ValueHashError extends TypeBoxError {
-    readonly value: unknown;
-    constructor(value: unknown);
-}
-/** Creates a FNV1A-64 non cryptographic hash of the given value */
-export declare function Hash(value: unknown): bigint;