claude-autopm 3.1.2 → 3.2.1

package/packages/plugin-cloud/node_modules/@sinclair/typebox/value/delta.js

@@ -1,204 +0,0 @@
-"use strict";
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/value
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueDelta = exports.ValueDeltaUnableToDiffUnknownValue = exports.ValueDeltaObjectWithSymbolKeyError = exports.Edit = exports.Delete = exports.Update = exports.Insert = void 0;
-const typebox_1 = require("../typebox");
-const is_1 = require("./is");
-const clone_1 = require("./clone");
-const pointer_1 = require("./pointer");
-exports.Insert = typebox_1.Type.Object({
-    type: typebox_1.Type.Literal('insert'),
-    path: typebox_1.Type.String(),
-    value: typebox_1.Type.Unknown(),
-});
-exports.Update = typebox_1.Type.Object({
-    type: typebox_1.Type.Literal('update'),
-    path: typebox_1.Type.String(),
-    value: typebox_1.Type.Unknown(),
-});
-exports.Delete = typebox_1.Type.Object({
-    type: typebox_1.Type.Literal('delete'),
-    path: typebox_1.Type.String(),
-});
-exports.Edit = typebox_1.Type.Union([exports.Insert, exports.Update, exports.Delete]);
-// ---------------------------------------------------------------------
-// Errors
-// ---------------------------------------------------------------------
-class ValueDeltaObjectWithSymbolKeyError extends Error {
-    constructor(key) {
-        super('ValueDelta: Cannot diff objects with symbol keys');
-        this.key = key;
-    }
-}
-exports.ValueDeltaObjectWithSymbolKeyError = ValueDeltaObjectWithSymbolKeyError;
-class ValueDeltaUnableToDiffUnknownValue extends Error {
-    constructor(value) {
-        super('ValueDelta: Unable to create diff edits for unknown value');
-        this.value = value;
-    }
-}
-exports.ValueDeltaUnableToDiffUnknownValue = ValueDeltaUnableToDiffUnknownValue;
-// ---------------------------------------------------------------------
-// ValueDelta
-// ---------------------------------------------------------------------
-var ValueDelta;
-(function (ValueDelta) {
-    // ---------------------------------------------------------------------
-    // Edits
-    // ---------------------------------------------------------------------
-    function Update(path, value) {
-        return { type: 'update', path, value };
-    }
-    function Insert(path, value) {
-        return { type: 'insert', path, value };
-    }
-    function Delete(path) {
-        return { type: 'delete', path };
-    }
-    // ---------------------------------------------------------------------
-    // Diff
-    // ---------------------------------------------------------------------
-    function* Object(path, current, next) {
-        if (!is_1.Is.Object(next))
-            return yield Update(path, next);
-        const currentKeys = [...globalThis.Object.keys(current), ...globalThis.Object.getOwnPropertySymbols(current)];
-        const nextKeys = [...globalThis.Object.keys(next), ...globalThis.Object.getOwnPropertySymbols(next)];
-        for (const key of currentKeys) {
-            if (typeof key === 'symbol')
-                throw new ValueDeltaObjectWithSymbolKeyError(key);
-            if (next[key] === undefined && nextKeys.includes(key))
-                yield Update(`${path}/${String(key)}`, undefined);
-        }
-        for (const key of nextKeys) {
-            if (current[key] === undefined || next[key] === undefined)
-                continue;
-            if (typeof key === 'symbol')
-                throw new ValueDeltaObjectWithSymbolKeyError(key);
-            yield* Visit(`${path}/${String(key)}`, current[key], next[key]);
-        }
-        for (const key of nextKeys) {
-            if (typeof key === 'symbol')
-                throw new ValueDeltaObjectWithSymbolKeyError(key);
-            if (current[key] === undefined)
-                yield Insert(`${path}/${String(key)}`, next[key]);
-        }
-        for (const key of currentKeys.reverse()) {
-            if (typeof key === 'symbol')
-                throw new ValueDeltaObjectWithSymbolKeyError(key);
-            if (next[key] === undefined && !nextKeys.includes(key))
-                yield Delete(`${path}/${String(key)}`);
-        }
-    }
-    function* Array(path, current, next) {
-        if (!is_1.Is.Array(next))
-            return yield Update(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 Insert(`${path}/${i}`, next[i]);
-        }
-        for (let i = current.length - 1; i >= 0; i--) {
-            if (i < next.length)
-                continue;
-            yield Delete(`${path}/${i}`);
-        }
-    }
-    function* TypedArray(path, current, next) {
-        if (!is_1.Is.TypedArray(next) || current.length !== next.length || globalThis.Object.getPrototypeOf(current).constructor.name !== globalThis.Object.getPrototypeOf(next).constructor.name)
-            return yield Update(path, next);
-        for (let i = 0; i < Math.min(current.length, next.length); i++) {
-            yield* Visit(`${path}/${i}`, current[i], next[i]);
-        }
-    }
-    function* Value(path, current, next) {
-        if (current === next)
-            return;
-        yield Update(path, next);
-    }
-    function* Visit(path, current, next) {
-        if (is_1.Is.Object(current)) {
-            return yield* Object(path, current, next);
-        }
-        else if (is_1.Is.Array(current)) {
-            return yield* Array(path, current, next);
-        }
-        else if (is_1.Is.TypedArray(current)) {
-            return yield* TypedArray(path, current, next);
-        }
-        else if (is_1.Is.Value(current)) {
-            return yield* Value(path, current, next);
-        }
-        else {
-            throw new ValueDeltaUnableToDiffUnknownValue(current);
-        }
-    }
-    function Diff(current, next) {
-        return [...Visit('', current, next)];
-    }
-    ValueDelta.Diff = Diff;
-    // ---------------------------------------------------------------------
-    // Patch
-    // ---------------------------------------------------------------------
-    function IsRootUpdate(edits) {
-        return edits.length > 0 && edits[0].path === '' && edits[0].type === 'update';
-    }
-    function IsIdentity(edits) {
-        return edits.length === 0;
-    }
-    function Patch(current, edits) {
-        if (IsRootUpdate(edits)) {
-            return clone_1.ValueClone.Clone(edits[0].value);
-        }
-        if (IsIdentity(edits)) {
-            return clone_1.ValueClone.Clone(current);
-        }
-        const clone = clone_1.ValueClone.Clone(current);
-        for (const edit of edits) {
-            switch (edit.type) {
-                case 'insert': {
-                    pointer_1.ValuePointer.Set(clone, edit.path, edit.value);
-                    break;
-                }
-                case 'update': {
-                    pointer_1.ValuePointer.Set(clone, edit.path, edit.value);
-                    break;
-                }
-                case 'delete': {
-                    pointer_1.ValuePointer.Delete(clone, edit.path);
-                    break;
-                }
-            }
-        }
-        return clone;
-    }
-    ValueDelta.Patch = Patch;
-})(ValueDelta = exports.ValueDelta || (exports.ValueDelta = {}));

package/packages/plugin-cloud/node_modules/@sinclair/typebox/value/equal.d.ts

@@ -1,3 +0,0 @@
-export declare namespace ValueEqual {
-    function Equal<T>(left: T, right: unknown): right is T;
-}

package/packages/plugin-cloud/node_modules/@sinclair/typebox/value/equal.js

@@ -1,80 +0,0 @@
-"use strict";
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/value
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueEqual = void 0;
-const is_1 = require("./is");
-var ValueEqual;
-(function (ValueEqual) {
-    function Object(left, right) {
-        if (!is_1.Is.Object(right))
-            return false;
-        const leftKeys = [...globalThis.Object.keys(left), ...globalThis.Object.getOwnPropertySymbols(left)];
-        const rightKeys = [...globalThis.Object.keys(right), ...globalThis.Object.getOwnPropertySymbols(right)];
-        if (leftKeys.length !== rightKeys.length)
-            return false;
-        return leftKeys.every((key) => Equal(left[key], right[key]));
-    }
-    function Date(left, right) {
-        return is_1.Is.Date(right) && left.getTime() === right.getTime();
-    }
-    function Array(left, right) {
-        if (!is_1.Is.Array(right) || left.length !== right.length)
-            return false;
-        return left.every((value, index) => Equal(value, right[index]));
-    }
-    function TypedArray(left, right) {
-        if (!is_1.Is.TypedArray(right) || left.length !== right.length || globalThis.Object.getPrototypeOf(left).constructor.name !== globalThis.Object.getPrototypeOf(right).constructor.name)
-            return false;
-        return left.every((value, index) => Equal(value, right[index]));
-    }
-    function Value(left, right) {
-        return left === right;
-    }
-    function Equal(left, right) {
-        if (is_1.Is.Object(left)) {
-            return Object(left, right);
-        }
-        else if (is_1.Is.Date(left)) {
-            return Date(left, right);
-        }
-        else if (is_1.Is.TypedArray(left)) {
-            return TypedArray(left, right);
-        }
-        else if (is_1.Is.Array(left)) {
-            return Array(left, right);
-        }
-        else if (is_1.Is.Value(left)) {
-            return Value(left, right);
-        }
-        else {
-            throw new Error('ValueEquals: Unable to compare value');
-        }
-    }
-    ValueEqual.Equal = Equal;
-})(ValueEqual = exports.ValueEqual || (exports.ValueEqual = {}));

package/packages/plugin-cloud/node_modules/@sinclair/typebox/value/hash.d.ts

@@ -1,8 +0,0 @@
-export declare class ValueHashError extends Error {
-    readonly value: unknown;
-    constructor(value: unknown);
-}
-export declare namespace ValueHash {
-    /** Creates a FNV1A-64 non cryptographic hash of the given value */
-    function Create(value: unknown): bigint;
-}

package/packages/plugin-cloud/node_modules/@sinclair/typebox/value/hash.js

@@ -1,208 +0,0 @@
-"use strict";
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/hash
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.ValueHash = exports.ValueHashError = void 0;
-class ValueHashError extends Error {
-    constructor(value) {
-        super(`Hash: Unable to hash value`);
-        this.value = value;
-    }
-}
-exports.ValueHashError = ValueHashError;
-var ValueHash;
-(function (ValueHash) {
-    let 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 Hash = globalThis.BigInt('14695981039346656037');
-    const [Prime, Size] = [globalThis.BigInt('1099511628211'), globalThis.BigInt('2') ** globalThis.BigInt('64')];
-    const Bytes = globalThis.Array.from({ length: 256 }).map((_, i) => globalThis.BigInt(i));
-    const F64 = new globalThis.Float64Array(1);
-    const F64In = new globalThis.DataView(F64.buffer);
-    const F64Out = new globalThis.Uint8Array(F64.buffer);
-    // ----------------------------------------------------
-    // Guards
-    // ----------------------------------------------------
-    function IsDate(value) {
-        return value instanceof globalThis.Date;
-    }
-    function IsUint8Array(value) {
-        return value instanceof globalThis.Uint8Array;
-    }
-    function IsArray(value) {
-        return globalThis.Array.isArray(value);
-    }
-    function IsBoolean(value) {
-        return typeof value === 'boolean';
-    }
-    function IsNull(value) {
-        return value === null;
-    }
-    function IsNumber(value) {
-        return typeof value === 'number';
-    }
-    function IsSymbol(value) {
-        return typeof value === 'symbol';
-    }
-    function IsBigInt(value) {
-        return typeof value === 'bigint';
-    }
-    function IsObject(value) {
-        return typeof value === 'object' && value !== null && !IsArray(value) && !IsDate(value) && !IsUint8Array(value);
-    }
-    function IsString(value) {
-        return typeof value === 'string';
-    }
-    function IsUndefined(value) {
-        return value === undefined;
-    }
-    // ----------------------------------------------------
-    // Encoding
-    // ----------------------------------------------------
-    function Array(value) {
-        FNV1A64(ByteMarker.Array);
-        for (const item of value) {
-            Visit(item);
-        }
-    }
-    function Boolean(value) {
-        FNV1A64(ByteMarker.Boolean);
-        FNV1A64(value ? 1 : 0);
-    }
-    function BigInt(value) {
-        FNV1A64(ByteMarker.BigInt);
-        F64In.setBigInt64(0, value);
-        for (const byte of F64Out) {
-            FNV1A64(byte);
-        }
-    }
-    function Date(value) {
-        FNV1A64(ByteMarker.Date);
-        Visit(value.getTime());
-    }
-    function Null(value) {
-        FNV1A64(ByteMarker.Null);
-    }
-    function Number(value) {
-        FNV1A64(ByteMarker.Number);
-        F64In.setFloat64(0, value);
-        for (const byte of F64Out) {
-            FNV1A64(byte);
-        }
-    }
-    function Object(value) {
-        FNV1A64(ByteMarker.Object);
-        for (const key of globalThis.Object.keys(value).sort()) {
-            Visit(key);
-            Visit(value[key]);
-        }
-    }
-    function String(value) {
-        FNV1A64(ByteMarker.String);
-        for (let i = 0; i < value.length; i++) {
-            FNV1A64(value.charCodeAt(i));
-        }
-    }
-    function Symbol(value) {
-        FNV1A64(ByteMarker.Symbol);
-        Visit(value.description);
-    }
-    function Uint8Array(value) {
-        FNV1A64(ByteMarker.Uint8Array);
-        for (let i = 0; i < value.length; i++) {
-            FNV1A64(value[i]);
-        }
-    }
-    function Undefined(value) {
-        return FNV1A64(ByteMarker.Undefined);
-    }
-    function Visit(value) {
-        if (IsArray(value)) {
-            Array(value);
-        }
-        else if (IsBoolean(value)) {
-            Boolean(value);
-        }
-        else if (IsBigInt(value)) {
-            BigInt(value);
-        }
-        else if (IsDate(value)) {
-            Date(value);
-        }
-        else if (IsNull(value)) {
-            Null(value);
-        }
-        else if (IsNumber(value)) {
-            Number(value);
-        }
-        else if (IsObject(value)) {
-            Object(value);
-        }
-        else if (IsString(value)) {
-            String(value);
-        }
-        else if (IsSymbol(value)) {
-            Symbol(value);
-        }
-        else if (IsUint8Array(value)) {
-            Uint8Array(value);
-        }
-        else if (IsUndefined(value)) {
-            Undefined(value);
-        }
-        else {
-            throw new ValueHashError(value);
-        }
-    }
-    function FNV1A64(byte) {
-        Hash = Hash ^ Bytes[byte];
-        Hash = (Hash * Prime) % Size;
-    }
-    /** Creates a FNV1A-64 non cryptographic hash of the given value */
-    function Create(value) {
-        Hash = globalThis.BigInt('14695981039346656037');
-        Visit(value);
-        return Hash;
-    }
-    ValueHash.Create = Create;
-})(ValueHash = exports.ValueHash || (exports.ValueHash = {}));

package/packages/plugin-cloud/node_modules/@sinclair/typebox/value/index.d.ts

@@ -1,6 +0,0 @@
-export { ValueError, ValueErrorIterator, ValueErrorType } from '../errors/index';
-export { ValueHash } from './hash';
-export { Edit, Insert, Update, Delete } from './delta';
-export { Mutable } from './mutate';
-export * from './pointer';
-export * from './value';

package/packages/plugin-cloud/node_modules/@sinclair/typebox/value/index.js

@@ -1,56 +0,0 @@
-"use strict";
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/value
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-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.Delete = exports.Update = exports.Insert = exports.Edit = exports.ValueHash = exports.ValueErrorType = exports.ValueErrorIterator = void 0;
-var index_1 = require("../errors/index");
-Object.defineProperty(exports, "ValueErrorIterator", { enumerable: true, get: function () { return index_1.ValueErrorIterator; } });
-Object.defineProperty(exports, "ValueErrorType", { enumerable: true, get: function () { return index_1.ValueErrorType; } });
-var hash_1 = require("./hash");
-Object.defineProperty(exports, "ValueHash", { enumerable: true, get: function () { return hash_1.ValueHash; } });
-var delta_1 = require("./delta");
-Object.defineProperty(exports, "Edit", { enumerable: true, get: function () { return delta_1.Edit; } });
-Object.defineProperty(exports, "Insert", { enumerable: true, get: function () { return delta_1.Insert; } });
-Object.defineProperty(exports, "Update", { enumerable: true, get: function () { return delta_1.Update; } });
-Object.defineProperty(exports, "Delete", { enumerable: true, get: function () { return delta_1.Delete; } });
-__exportStar(require("./pointer"), exports);
-__exportStar(require("./value"), exports);

package/packages/plugin-cloud/node_modules/@sinclair/typebox/value/is.d.ts

@@ -1,11 +0,0 @@
-export type ValueType = null | undefined | Function | symbol | bigint | number | boolean | string;
-export type ObjectType = Record<string | number | symbol, unknown>;
-export type TypedArrayType = Int8Array | Uint8Array | Uint8ClampedArray | Int16Array | Uint16Array | Int32Array | Uint32Array | Float32Array | Float64Array | BigInt64Array | BigUint64Array;
-export type ArrayType = unknown[];
-export declare namespace Is {
-    function Object(value: unknown): value is ObjectType;
-    function Date(value: unknown): value is Date;
-    function Array(value: unknown): value is ArrayType;
-    function Value(value: unknown): value is ValueType;
-    function TypedArray(value: unknown): value is TypedArrayType;
-}

package/packages/plugin-cloud/node_modules/@sinclair/typebox/value/is.js

@@ -1,53 +0,0 @@
-"use strict";
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/value
-
-The MIT License (MIT)
-
-Copyright (c) 2017-2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.
-
----------------------------------------------------------------------------*/
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.Is = void 0;
-var Is;
-(function (Is) {
-    function Object(value) {
-        return value !== null && typeof value === 'object' && !globalThis.Array.isArray(value) && !ArrayBuffer.isView(value) && !(value instanceof globalThis.Date);
-    }
-    Is.Object = Object;
-    function Date(value) {
-        return value instanceof globalThis.Date;
-    }
-    Is.Date = Date;
-    function Array(value) {
-        return globalThis.Array.isArray(value) && !ArrayBuffer.isView(value);
-    }
-    Is.Array = Array;
-    function Value(value) {
-        return value === null || value === undefined || typeof value === 'function' || typeof value === 'symbol' || typeof value === 'bigint' || typeof value === 'number' || typeof value === 'boolean' || typeof value === 'string';
-    }
-    Is.Value = Value;
-    function TypedArray(value) {
-        return ArrayBuffer.isView(value);
-    }
-    Is.TypedArray = TypedArray;
-})(Is = exports.Is || (exports.Is = {}));

package/packages/plugin-cloud/node_modules/@sinclair/typebox/value/mutate.d.ts

@@ -1,13 +0,0 @@
-export declare class ValueMutateTypeMismatchError extends Error {
-    constructor();
-}
-export declare class ValueMutateInvalidRootMutationError extends Error {
-    constructor();
-}
-export type Mutable = {
-    [key: string]: unknown;
-} | unknown[];
-export declare namespace ValueMutate {
-    /** Performs a deep mutable value assignment while retaining internal references. */
-    function Mutate(current: Mutable, next: Mutable): void;
-}