@depup/sinclair__typebox 0.34.48-depup.0

package/build/cjs/value/guard/guard.d.ts

@@ -0,0 +1,74 @@
+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/build/cjs/value/guard/guard.js

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

package/build/cjs/value/guard/index.d.ts

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

package/build/cjs/value/guard/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./guard"), exports);

package/build/cjs/value/hash/hash.d.ts

@@ -0,0 +1,7 @@
+import { TypeBoxError } from '../../type/error/index';
+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;

package/build/cjs/value/hash/hash.js

@@ -0,0 +1,152 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ValueHashError = void 0;
+exports.Hash = Hash;
+const index_1 = require("../guard/index");
+const index_2 = require("../../type/error/index");
+// ------------------------------------------------------------------
+// Errors
+// ------------------------------------------------------------------
+class ValueHashError extends index_2.TypeBoxError {
+    constructor(value) {
+        super(`Unable to hash value`);
+        this.value = value;
+    }
+}
+exports.ValueHashError = ValueHashError;
+// ------------------------------------------------------------------
+// ByteMarker
+// ------------------------------------------------------------------
+var ByteMarker;
+(function (ByteMarker) {
+    ByteMarker[ByteMarker["Undefined"] = 0] = "Undefined";
+    ByteMarker[ByteMarker["Null"] = 1] = "Null";
+    ByteMarker[ByteMarker["Boolean"] = 2] = "Boolean";
+    ByteMarker[ByteMarker["Number"] = 3] = "Number";
+    ByteMarker[ByteMarker["String"] = 4] = "String";
+    ByteMarker[ByteMarker["Object"] = 5] = "Object";
+    ByteMarker[ByteMarker["Array"] = 6] = "Array";
+    ByteMarker[ByteMarker["Date"] = 7] = "Date";
+    ByteMarker[ByteMarker["Uint8Array"] = 8] = "Uint8Array";
+    ByteMarker[ByteMarker["Symbol"] = 9] = "Symbol";
+    ByteMarker[ByteMarker["BigInt"] = 10] = "BigInt";
+})(ByteMarker || (ByteMarker = {}));
+// ------------------------------------------------------------------
+// State
+// ------------------------------------------------------------------
+let Accumulator = BigInt('14695981039346656037');
+const [Prime, Size] = [BigInt('1099511628211'), BigInt('18446744073709551616' /* 2 ^ 64 */)];
+const Bytes = Array.from({ length: 256 }).map((_, i) => BigInt(i));
+const F64 = new Float64Array(1);
+const F64In = new DataView(F64.buffer);
+const F64Out = new Uint8Array(F64.buffer);
+// ------------------------------------------------------------------
+// NumberToBytes
+// ------------------------------------------------------------------
+function* NumberToBytes(value) {
+    const byteCount = value === 0 ? 1 : Math.ceil(Math.floor(Math.log2(value) + 1) / 8);
+    for (let i = 0; i < byteCount; i++) {
+        yield (value >> (8 * (byteCount - 1 - i))) & 0xff;
+    }
+}
+// ------------------------------------------------------------------
+// Hashing Functions
+// ------------------------------------------------------------------
+function ArrayType(value) {
+    FNV1A64(ByteMarker.Array);
+    for (const item of value) {
+        Visit(item);
+    }
+}
+function BooleanType(value) {
+    FNV1A64(ByteMarker.Boolean);
+    FNV1A64(value ? 1 : 0);
+}
+function BigIntType(value) {
+    FNV1A64(ByteMarker.BigInt);
+    F64In.setBigInt64(0, value);
+    for (const byte of F64Out) {
+        FNV1A64(byte);
+    }
+}
+function DateType(value) {
+    FNV1A64(ByteMarker.Date);
+    Visit(value.getTime());
+}
+function NullType(value) {
+    FNV1A64(ByteMarker.Null);
+}
+function NumberType(value) {
+    FNV1A64(ByteMarker.Number);
+    F64In.setFloat64(0, value);
+    for (const byte of F64Out) {
+        FNV1A64(byte);
+    }
+}
+function ObjectType(value) {
+    FNV1A64(ByteMarker.Object);
+    for (const key of globalThis.Object.getOwnPropertyNames(value).sort()) {
+        Visit(key);
+        Visit(value[key]);
+    }
+}
+function StringType(value) {
+    FNV1A64(ByteMarker.String);
+    for (let i = 0; i < value.length; i++) {
+        for (const byte of NumberToBytes(value.charCodeAt(i))) {
+            FNV1A64(byte);
+        }
+    }
+}
+function SymbolType(value) {
+    FNV1A64(ByteMarker.Symbol);
+    Visit(value.description);
+}
+function Uint8ArrayType(value) {
+    FNV1A64(ByteMarker.Uint8Array);
+    for (let i = 0; i < value.length; i++) {
+        FNV1A64(value[i]);
+    }
+}
+function UndefinedType(value) {
+    return FNV1A64(ByteMarker.Undefined);
+}
+function Visit(value) {
+    if ((0, index_1.IsArray)(value))
+        return ArrayType(value);
+    if ((0, index_1.IsBoolean)(value))
+        return BooleanType(value);
+    if ((0, index_1.IsBigInt)(value))
+        return BigIntType(value);
+    if ((0, index_1.IsDate)(value))
+        return DateType(value);
+    if ((0, index_1.IsNull)(value))
+        return NullType(value);
+    if ((0, index_1.IsNumber)(value))
+        return NumberType(value);
+    if ((0, index_1.IsObject)(value))
+        return ObjectType(value);
+    if ((0, index_1.IsString)(value))
+        return StringType(value);
+    if ((0, index_1.IsSymbol)(value))
+        return SymbolType(value);
+    if ((0, index_1.IsUint8Array)(value))
+        return Uint8ArrayType(value);
+    if ((0, index_1.IsUndefined)(value))
+        return UndefinedType(value);
+    throw new ValueHashError(value);
+}
+function FNV1A64(byte) {
+    Accumulator = Accumulator ^ Bytes[byte];
+    Accumulator = (Accumulator * Prime) % Size;
+}
+// ------------------------------------------------------------------
+// Hash
+// ------------------------------------------------------------------
+/** Creates a FNV1A-64 non cryptographic hash of the given value */
+function Hash(value) {
+    Accumulator = BigInt('14695981039346656037');
+    Visit(value);
+    return Accumulator;
+}

package/build/cjs/value/hash/index.d.ts

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

package/build/cjs/value/hash/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./hash"), exports);

package/build/cjs/value/index.d.ts

@@ -0,0 +1,20 @@
+export { ValueError, ValueErrorType, ValueErrorIterator } from '../errors/index';
+export * from './guard/index';
+export * from './assert/index';
+export * from './cast/index';
+export * from './check/index';
+export * from './clean/index';
+export * from './clone/index';
+export * from './convert/index';
+export * from './create/index';
+export * from './decode/index';
+export * from './default/index';
+export * from './delta/index';
+export * from './encode/index';
+export * from './equal/index';
+export * from './hash/index';
+export * from './mutate/index';
+export * from './parse/index';
+export * from './pointer/index';
+export * from './transform/index';
+export { Value } from './value/index';

package/build/cjs/value/index.js

@@ -0,0 +1,53 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Value = exports.ValueErrorIterator = exports.ValueErrorType = void 0;
+// ------------------------------------------------------------------
+// Errors (re-export)
+// ------------------------------------------------------------------
+var index_1 = require("../errors/index");
+Object.defineProperty(exports, "ValueErrorType", { enumerable: true, get: function () { return index_1.ValueErrorType; } });
+Object.defineProperty(exports, "ValueErrorIterator", { enumerable: true, get: function () { return index_1.ValueErrorIterator; } });
+// ------------------------------------------------------------------
+// Guards
+// ------------------------------------------------------------------
+__exportStar(require("./guard/index"), exports);
+// ------------------------------------------------------------------
+// Operators
+// ------------------------------------------------------------------
+__exportStar(require("./assert/index"), exports);
+__exportStar(require("./cast/index"), exports);
+__exportStar(require("./check/index"), exports);
+__exportStar(require("./clean/index"), exports);
+__exportStar(require("./clone/index"), exports);
+__exportStar(require("./convert/index"), exports);
+__exportStar(require("./create/index"), exports);
+__exportStar(require("./decode/index"), exports);
+__exportStar(require("./default/index"), exports);
+__exportStar(require("./delta/index"), exports);
+__exportStar(require("./encode/index"), exports);
+__exportStar(require("./equal/index"), exports);
+__exportStar(require("./hash/index"), exports);
+__exportStar(require("./mutate/index"), exports);
+__exportStar(require("./parse/index"), exports);
+__exportStar(require("./pointer/index"), exports);
+__exportStar(require("./transform/index"), exports);
+// ------------------------------------------------------------------
+// Namespace
+// ------------------------------------------------------------------
+var index_2 = require("./value/index");
+Object.defineProperty(exports, "Value", { enumerable: true, get: function () { return index_2.Value; } });

package/build/cjs/value/mutate/index.d.ts

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

package/build/cjs/value/mutate/index.js

@@ -0,0 +1,18 @@
+"use strict";
+
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./mutate"), exports);

package/build/cjs/value/mutate/mutate.d.ts

@@ -0,0 +1,9 @@
+import { TypeBoxError } from '../../type/error/index';
+export declare class ValueMutateError extends TypeBoxError {
+    constructor(message: string);
+}
+export type Mutable = {
+    [key: string]: unknown;
+} | unknown[];
+/** `[Mutable]` Performs a deep mutable value assignment while retaining internal references */
+export declare function Mutate(current: Mutable, next: Mutable): void;