claude-autopm 3.1.2 → 3.2.1

package/packages/plugin-devops/node_modules/@jest/types/build/index.js

@@ -1 +0,0 @@
-'use strict';

package/packages/plugin-devops/node_modules/@jest/types/package.json

@@ -1,38 +0,0 @@
-{
-  "name": "@jest/types",
-  "version": "29.6.3",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/jestjs/jest.git",
-    "directory": "packages/jest-types"
-  },
-  "engines": {
-    "node": "^14.15.0 || ^16.10.0 || >=18.0.0"
-  },
-  "license": "MIT",
-  "main": "./build/index.js",
-  "types": "./build/index.d.ts",
-  "exports": {
-    ".": {
-      "types": "./build/index.d.ts",
-      "default": "./build/index.js"
-    },
-    "./package.json": "./package.json"
-  },
-  "dependencies": {
-    "@jest/schemas": "^29.6.3",
-    "@types/istanbul-lib-coverage": "^2.0.0",
-    "@types/istanbul-reports": "^3.0.0",
-    "@types/node": "*",
-    "@types/yargs": "^17.0.8",
-    "chalk": "^4.0.0"
-  },
-  "devDependencies": {
-    "@tsd/typescript": "^5.0.4",
-    "tsd-lite": "^0.7.0"
-  },
-  "publishConfig": {
-    "access": "public"
-  },
-  "gitHead": "fb7d95c8af6e0d65a8b65348433d8a0ea0725b5b"
-}

package/packages/plugin-devops/node_modules/@sinclair/typebox/compiler/compiler.d.ts

@@ -1,35 +0,0 @@
-import * as Types from '../typebox';
-import { ValueErrorIterator } from '../errors/index';
-export type CheckFunction = (value: unknown) => boolean;
-export declare class TypeCheck<T extends Types.TSchema> {
-    private readonly schema;
-    private readonly references;
-    private readonly checkFunc;
-    private readonly code;
-    constructor(schema: T, references: Types.TSchema[], checkFunc: CheckFunction, code: string);
-    /** Returns the generated assertion code used to validate this type. */
-    Code(): string;
-    /** Returns an iterator for each error in this value. */
-    Errors(value: unknown): ValueErrorIterator;
-    /** Returns true if the value matches the compiled type. */
-    Check(value: unknown): value is Types.Static<T>;
-}
-export declare class TypeCompilerUnknownTypeError extends Error {
-    readonly schema: Types.TSchema;
-    constructor(schema: Types.TSchema);
-}
-export declare class TypeCompilerDereferenceError extends Error {
-    readonly schema: Types.TRef;
-    constructor(schema: Types.TRef);
-}
-export declare class TypeCompilerTypeGuardError extends Error {
-    readonly schema: Types.TSchema;
-    constructor(schema: Types.TSchema);
-}
-/** Compiles Types for Runtime Type Checking */
-export declare namespace TypeCompiler {
-    /** Returns the generated assertion code used to validate this type. */
-    function Code<T extends Types.TSchema>(schema: T, references?: Types.TSchema[]): string;
-    /** Compiles the given type for runtime type checking. This compiler only accepts known TypeBox types non-inclusive of unsafe types. */
-    function Compile<T extends Types.TSchema>(schema: T, references?: Types.TSchema[]): TypeCheck<T>;
-}

package/packages/plugin-devops/node_modules/@sinclair/typebox/compiler/compiler.js

@@ -1,577 +0,0 @@
-"use strict";
-/*--------------------------------------------------------------------------
-
-@sinclair/typebox/compiler
-
-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.TypeCompiler = exports.TypeCompilerTypeGuardError = exports.TypeCompilerDereferenceError = exports.TypeCompilerUnknownTypeError = exports.TypeCheck = void 0;
-const Types = require("../typebox");
-const index_1 = require("../errors/index");
-const index_2 = require("../system/index");
-const hash_1 = require("../value/hash");
-// -------------------------------------------------------------------
-// TypeCheck
-// -------------------------------------------------------------------
-class TypeCheck {
-    constructor(schema, references, checkFunc, code) {
-        this.schema = schema;
-        this.references = references;
-        this.checkFunc = checkFunc;
-        this.code = code;
-    }
-    /** Returns the generated assertion code used to validate this type. */
-    Code() {
-        return this.code;
-    }
-    /** Returns an iterator for each error in this value. */
-    Errors(value) {
-        return index_1.ValueErrors.Errors(this.schema, this.references, value);
-    }
-    /** Returns true if the value matches the compiled type. */
-    Check(value) {
-        return this.checkFunc(value);
-    }
-}
-exports.TypeCheck = TypeCheck;
-// -------------------------------------------------------------------
-// Character
-// -------------------------------------------------------------------
-var Character;
-(function (Character) {
-    function DollarSign(code) {
-        return code === 36;
-    }
-    Character.DollarSign = DollarSign;
-    function IsUnderscore(code) {
-        return code === 95;
-    }
-    Character.IsUnderscore = IsUnderscore;
-    function IsAlpha(code) {
-        return (code >= 65 && code <= 90) || (code >= 97 && code <= 122);
-    }
-    Character.IsAlpha = IsAlpha;
-    function IsNumeric(code) {
-        return code >= 48 && code <= 57;
-    }
-    Character.IsNumeric = IsNumeric;
-})(Character || (Character = {}));
-// -------------------------------------------------------------------
-// MemberExpression
-// -------------------------------------------------------------------
-var MemberExpression;
-(function (MemberExpression) {
-    function IsFirstCharacterNumeric(value) {
-        if (value.length === 0)
-            return false;
-        return Character.IsNumeric(value.charCodeAt(0));
-    }
-    function IsAccessor(value) {
-        if (IsFirstCharacterNumeric(value))
-            return false;
-        for (let i = 0; i < value.length; i++) {
-            const code = value.charCodeAt(i);
-            const check = Character.IsAlpha(code) || Character.IsNumeric(code) || Character.DollarSign(code) || Character.IsUnderscore(code);
-            if (!check)
-                return false;
-        }
-        return true;
-    }
-    function EscapeHyphen(key) {
-        return key.replace(/'/g, "\\'");
-    }
-    function Encode(object, key) {
-        return IsAccessor(key) ? `${object}.${key}` : `${object}['${EscapeHyphen(key)}']`;
-    }
-    MemberExpression.Encode = Encode;
-})(MemberExpression || (MemberExpression = {}));
-// -------------------------------------------------------------------
-// Identifier
-// -------------------------------------------------------------------
-var Identifier;
-(function (Identifier) {
-    function Encode($id) {
-        const buffer = [];
-        for (let i = 0; i < $id.length; i++) {
-            const code = $id.charCodeAt(i);
-            if (Character.IsNumeric(code) || Character.IsAlpha(code)) {
-                buffer.push($id.charAt(i));
-            }
-            else {
-                buffer.push(`_${code}_`);
-            }
-        }
-        return buffer.join('').replace(/__/g, '_');
-    }
-    Identifier.Encode = Encode;
-})(Identifier || (Identifier = {}));
-// -------------------------------------------------------------------
-// TypeCompiler
-// -------------------------------------------------------------------
-class TypeCompilerUnknownTypeError extends Error {
-    constructor(schema) {
-        super('TypeCompiler: Unknown type');
-        this.schema = schema;
-    }
-}
-exports.TypeCompilerUnknownTypeError = TypeCompilerUnknownTypeError;
-class TypeCompilerDereferenceError extends Error {
-    constructor(schema) {
-        super(`TypeCompiler: Unable to dereference schema with $id '${schema.$ref}'`);
-        this.schema = schema;
-    }
-}
-exports.TypeCompilerDereferenceError = TypeCompilerDereferenceError;
-class TypeCompilerTypeGuardError extends Error {
-    constructor(schema) {
-        super('TypeCompiler: Preflight validation check failed to guard for the given schema');
-        this.schema = schema;
-    }
-}
-exports.TypeCompilerTypeGuardError = TypeCompilerTypeGuardError;
-/** Compiles Types for Runtime Type Checking */
-var TypeCompiler;
-(function (TypeCompiler) {
-    // -------------------------------------------------------------------
-    // Guards
-    // -------------------------------------------------------------------
-    function IsBigInt(value) {
-        return typeof value === 'bigint';
-    }
-    function IsNumber(value) {
-        return typeof value === 'number' && globalThis.Number.isFinite(value);
-    }
-    function IsString(value) {
-        return typeof value === 'string';
-    }
-    // -------------------------------------------------------------------
-    // Polices
-    // -------------------------------------------------------------------
-    function IsExactOptionalProperty(value, key, expression) {
-        return index_2.TypeSystem.ExactOptionalPropertyTypes ? `('${key}' in ${value} ? ${expression} : true)` : `(${MemberExpression.Encode(value, key)} !== undefined ? ${expression} : true)`;
-    }
-    function IsObjectCheck(value) {
-        return !index_2.TypeSystem.AllowArrayObjects ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}))` : `(typeof ${value} === 'object' && ${value} !== null)`;
-    }
-    function IsRecordCheck(value) {
-        return !index_2.TypeSystem.AllowArrayObjects
-            ? `(typeof ${value} === 'object' && ${value} !== null && !Array.isArray(${value}) && !(${value} instanceof Date) && !(${value} instanceof Uint8Array))`
-            : `(typeof ${value} === 'object' && ${value} !== null && !(${value} instanceof Date) && !(${value} instanceof Uint8Array))`;
-    }
-    function IsNumberCheck(value) {
-        return !index_2.TypeSystem.AllowNaN ? `(typeof ${value} === 'number' && Number.isFinite(${value}))` : `typeof ${value} === 'number'`;
-    }
-    function IsVoidCheck(value) {
-        return index_2.TypeSystem.AllowVoidNull ? `(${value} === undefined || ${value} === null)` : `${value} === undefined`;
-    }
-    // -------------------------------------------------------------------
-    // Types
-    // -------------------------------------------------------------------
-    function* Any(schema, references, value) {
-        yield 'true';
-    }
-    function* Array(schema, references, value) {
-        const expression = CreateExpression(schema.items, references, 'value');
-        yield `Array.isArray(${value}) && ${value}.every(value => ${expression})`;
-        if (IsNumber(schema.minItems))
-            yield `${value}.length >= ${schema.minItems}`;
-        if (IsNumber(schema.maxItems))
-            yield `${value}.length <= ${schema.maxItems}`;
-        if (schema.uniqueItems === true)
-            yield `((function() { const set = new Set(); for(const element of ${value}) { const hashed = hash(element); if(set.has(hashed)) { return false } else { set.add(hashed) } } return true })())`;
-    }
-    function* BigInt(schema, references, value) {
-        yield `(typeof ${value} === 'bigint')`;
-        if (IsBigInt(schema.multipleOf))
-            yield `(${value} % BigInt(${schema.multipleOf})) === 0`;
-        if (IsBigInt(schema.exclusiveMinimum))
-            yield `${value} > BigInt(${schema.exclusiveMinimum})`;
-        if (IsBigInt(schema.exclusiveMaximum))
-            yield `${value} < BigInt(${schema.exclusiveMaximum})`;
-        if (IsBigInt(schema.minimum))
-            yield `${value} >= BigInt(${schema.minimum})`;
-        if (IsBigInt(schema.maximum))
-            yield `${value} <= BigInt(${schema.maximum})`;
-    }
-    function* Boolean(schema, references, value) {
-        yield `typeof ${value} === 'boolean'`;
-    }
-    function* Constructor(schema, references, value) {
-        yield* Visit(schema.returns, references, `${value}.prototype`);
-    }
-    function* Date(schema, references, value) {
-        yield `(${value} instanceof Date) && Number.isFinite(${value}.getTime())`;
-        if (IsNumber(schema.exclusiveMinimumTimestamp))
-            yield `${value}.getTime() > ${schema.exclusiveMinimumTimestamp}`;
-        if (IsNumber(schema.exclusiveMaximumTimestamp))
-            yield `${value}.getTime() < ${schema.exclusiveMaximumTimestamp}`;
-        if (IsNumber(schema.minimumTimestamp))
-            yield `${value}.getTime() >= ${schema.minimumTimestamp}`;
-        if (IsNumber(schema.maximumTimestamp))
-            yield `${value}.getTime() <= ${schema.maximumTimestamp}`;
-    }
-    function* Function(schema, references, value) {
-        yield `typeof ${value} === 'function'`;
-    }
-    function* Integer(schema, references, value) {
-        yield `(typeof ${value} === 'number' && Number.isInteger(${value}))`;
-        if (IsNumber(schema.multipleOf))
-            yield `(${value} % ${schema.multipleOf}) === 0`;
-        if (IsNumber(schema.exclusiveMinimum))
-            yield `${value} > ${schema.exclusiveMinimum}`;
-        if (IsNumber(schema.exclusiveMaximum))
-            yield `${value} < ${schema.exclusiveMaximum}`;
-        if (IsNumber(schema.minimum))
-            yield `${value} >= ${schema.minimum}`;
-        if (IsNumber(schema.maximum))
-            yield `${value} <= ${schema.maximum}`;
-    }
-    function* Intersect(schema, references, value) {
-        if (schema.unevaluatedProperties === undefined) {
-            const expressions = schema.allOf.map((schema) => CreateExpression(schema, references, value));
-            yield `${expressions.join(' && ')}`;
-        }
-        else if (schema.unevaluatedProperties === false) {
-            // prettier-ignore
-            const schemaKeys = Types.KeyResolver.Resolve(schema).map((key) => `'${key}'`).join(', ');
-            const expressions = schema.allOf.map((schema) => CreateExpression(schema, references, value));
-            const expression1 = `Object.getOwnPropertyNames(${value}).every(key => [${schemaKeys}].includes(key))`;
-            yield `${expressions.join(' && ')} && ${expression1}`;
-        }
-        else if (typeof schema.unevaluatedProperties === 'object') {
-            // prettier-ignore
-            const schemaKeys = Types.KeyResolver.Resolve(schema).map((key) => `'${key}'`).join(', ');
-            const expressions = schema.allOf.map((schema) => CreateExpression(schema, references, value));
-            const expression1 = CreateExpression(schema.unevaluatedProperties, references, 'value[key]');
-            const expression2 = `Object.getOwnPropertyNames(${value}).every(key => [${schemaKeys}].includes(key) || ${expression1})`;
-            yield `${expressions.join(' && ')} && ${expression2}`;
-        }
-    }
-    function* Literal(schema, references, value) {
-        if (typeof schema.const === 'number' || typeof schema.const === 'boolean') {
-            yield `${value} === ${schema.const}`;
-        }
-        else {
-            yield `${value} === '${schema.const}'`;
-        }
-    }
-    function* Never(schema, references, value) {
-        yield `false`;
-    }
-    function* Not(schema, references, value) {
-        const left = CreateExpression(schema.allOf[0].not, references, value);
-        const right = CreateExpression(schema.allOf[1], references, value);
-        yield `!${left} && ${right}`;
-    }
-    function* Null(schema, references, value) {
-        yield `${value} === null`;
-    }
-    function* Number(schema, references, value) {
-        yield IsNumberCheck(value);
-        if (IsNumber(schema.multipleOf))
-            yield `(${value} % ${schema.multipleOf}) === 0`;
-        if (IsNumber(schema.exclusiveMinimum))
-            yield `${value} > ${schema.exclusiveMinimum}`;
-        if (IsNumber(schema.exclusiveMaximum))
-            yield `${value} < ${schema.exclusiveMaximum}`;
-        if (IsNumber(schema.minimum))
-            yield `${value} >= ${schema.minimum}`;
-        if (IsNumber(schema.maximum))
-            yield `${value} <= ${schema.maximum}`;
-    }
-    function* Object(schema, references, value) {
-        yield IsObjectCheck(value);
-        if (IsNumber(schema.minProperties))
-            yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
-        if (IsNumber(schema.maxProperties))
-            yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`;
-        const knownKeys = globalThis.Object.getOwnPropertyNames(schema.properties);
-        for (const knownKey of knownKeys) {
-            const memberExpression = MemberExpression.Encode(value, knownKey);
-            const property = schema.properties[knownKey];
-            if (schema.required && schema.required.includes(knownKey)) {
-                yield* Visit(property, references, memberExpression);
-                if (Types.ExtendsUndefined.Check(property))
-                    yield `('${knownKey}' in ${value})`;
-            }
-            else {
-                const expression = CreateExpression(property, references, memberExpression);
-                yield IsExactOptionalProperty(value, knownKey, expression);
-            }
-        }
-        if (schema.additionalProperties === false) {
-            if (schema.required && schema.required.length === knownKeys.length) {
-                yield `Object.getOwnPropertyNames(${value}).length === ${knownKeys.length}`;
-            }
-            else {
-                const keys = `[${knownKeys.map((key) => `'${key}'`).join(', ')}]`;
-                yield `Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key))`;
-            }
-        }
-        if (typeof schema.additionalProperties === 'object') {
-            const expression = CreateExpression(schema.additionalProperties, references, 'value[key]');
-            const keys = `[${knownKeys.map((key) => `'${key}'`).join(', ')}]`;
-            yield `(Object.getOwnPropertyNames(${value}).every(key => ${keys}.includes(key) || ${expression}))`;
-        }
-    }
-    function* Promise(schema, references, value) {
-        yield `(typeof value === 'object' && typeof ${value}.then === 'function')`;
-    }
-    function* Record(schema, references, value) {
-        yield IsRecordCheck(value);
-        if (IsNumber(schema.minProperties))
-            yield `Object.getOwnPropertyNames(${value}).length >= ${schema.minProperties}`;
-        if (IsNumber(schema.maxProperties))
-            yield `Object.getOwnPropertyNames(${value}).length <= ${schema.maxProperties}`;
-        const [keyPattern, valueSchema] = globalThis.Object.entries(schema.patternProperties)[0];
-        const local = PushLocal(`new RegExp(/${keyPattern}/)`);
-        yield `(Object.getOwnPropertyNames(${value}).every(key => ${local}.test(key)))`;
-        const expression = CreateExpression(valueSchema, references, 'value');
-        yield `Object.values(${value}).every(value => ${expression})`;
-    }
-    function* Ref(schema, references, value) {
-        const index = references.findIndex((foreign) => foreign.$id === schema.$ref);
-        if (index === -1)
-            throw new TypeCompilerDereferenceError(schema);
-        const target = references[index];
-        // Reference: If we have seen this reference before we can just yield and return
-        // the function call. If this isn't the case we defer to visit to generate and
-        // set the function for subsequent passes. Consider for refactor.
-        if (state_local_function_names.has(schema.$ref))
-            return yield `${CreateFunctionName(schema.$ref)}(${value})`;
-        yield* Visit(target, references, value);
-    }
-    function* String(schema, references, value) {
-        yield `(typeof ${value} === 'string')`;
-        if (IsNumber(schema.minLength))
-            yield `${value}.length >= ${schema.minLength}`;
-        if (IsNumber(schema.maxLength))
-            yield `${value}.length <= ${schema.maxLength}`;
-        if (schema.pattern !== undefined) {
-            const local = PushLocal(`${new RegExp(schema.pattern)};`);
-            yield `${local}.test(${value})`;
-        }
-        if (schema.format !== undefined) {
-            yield `format('${schema.format}', ${value})`;
-        }
-    }
-    function* Symbol(schema, references, value) {
-        yield `(typeof ${value} === 'symbol')`;
-    }
-    function* TemplateLiteral(schema, references, value) {
-        yield `(typeof ${value} === 'string')`;
-        const local = PushLocal(`${new RegExp(schema.pattern)};`);
-        yield `${local}.test(${value})`;
-    }
-    function* This(schema, references, value) {
-        const func = CreateFunctionName(schema.$ref);
-        yield `${func}(${value})`;
-    }
-    function* Tuple(schema, references, value) {
-        yield `(Array.isArray(${value}))`;
-        if (schema.items === undefined)
-            return yield `${value}.length === 0`;
-        yield `(${value}.length === ${schema.maxItems})`;
-        for (let i = 0; i < schema.items.length; i++) {
-            const expression = CreateExpression(schema.items[i], references, `${value}[${i}]`);
-            yield `${expression}`;
-        }
-    }
-    function* Undefined(schema, references, value) {
-        yield `${value} === undefined`;
-    }
-    function* Union(schema, references, value) {
-        const expressions = schema.anyOf.map((schema) => CreateExpression(schema, references, value));
-        yield `(${expressions.join(' || ')})`;
-    }
-    function* Uint8Array(schema, references, value) {
-        yield `${value} instanceof Uint8Array`;
-        if (IsNumber(schema.maxByteLength))
-            yield `(${value}.length <= ${schema.maxByteLength})`;
-        if (IsNumber(schema.minByteLength))
-            yield `(${value}.length >= ${schema.minByteLength})`;
-    }
-    function* Unknown(schema, references, value) {
-        yield 'true';
-    }
-    function* Void(schema, references, value) {
-        yield IsVoidCheck(value);
-    }
-    function* UserDefined(schema, references, value) {
-        const schema_key = `schema_key_${state_remote_custom_types.size}`;
-        state_remote_custom_types.set(schema_key, schema);
-        yield `custom('${schema[Types.Kind]}', '${schema_key}', ${value})`;
-    }
-    function* Visit(schema, references, value) {
-        const references_ = IsString(schema.$id) ? [...references, schema] : references;
-        const schema_ = schema;
-        // Reference: Referenced schemas can originate from either additional schemas
-        // or inline in the schema itself. Ideally the recursive path should align to
-        // reference path. Consider for refactor.
-        if (IsString(schema.$id) && !state_local_function_names.has(schema.$id)) {
-            state_local_function_names.add(schema.$id);
-            const name = CreateFunctionName(schema.$id);
-            const body = CreateFunction(name, schema, references, 'value');
-            PushFunction(body);
-            yield `${name}(${value})`;
-            return;
-        }
-        switch (schema_[Types.Kind]) {
-            case 'Any':
-                return yield* Any(schema_, references_, value);
-            case 'Array':
-                return yield* Array(schema_, references_, value);
-            case 'BigInt':
-                return yield* BigInt(schema_, references_, value);
-            case 'Boolean':
-                return yield* Boolean(schema_, references_, value);
-            case 'Constructor':
-                return yield* Constructor(schema_, references_, value);
-            case 'Date':
-                return yield* Date(schema_, references_, value);
-            case 'Function':
-                return yield* Function(schema_, references_, value);
-            case 'Integer':
-                return yield* Integer(schema_, references_, value);
-            case 'Intersect':
-                return yield* Intersect(schema_, references_, value);
-            case 'Literal':
-                return yield* Literal(schema_, references_, value);
-            case 'Never':
-                return yield* Never(schema_, references_, value);
-            case 'Not':
-                return yield* Not(schema_, references_, value);
-            case 'Null':
-                return yield* Null(schema_, references_, value);
-            case 'Number':
-                return yield* Number(schema_, references_, value);
-            case 'Object':
-                return yield* Object(schema_, references_, value);
-            case 'Promise':
-                return yield* Promise(schema_, references_, value);
-            case 'Record':
-                return yield* Record(schema_, references_, value);
-            case 'Ref':
-                return yield* Ref(schema_, references_, value);
-            case 'String':
-                return yield* String(schema_, references_, value);
-            case 'Symbol':
-                return yield* Symbol(schema_, references_, value);
-            case 'TemplateLiteral':
-                return yield* TemplateLiteral(schema_, references_, value);
-            case 'This':
-                return yield* This(schema_, references_, value);
-            case 'Tuple':
-                return yield* Tuple(schema_, references_, value);
-            case 'Undefined':
-                return yield* Undefined(schema_, references_, value);
-            case 'Union':
-                return yield* Union(schema_, references_, value);
-            case 'Uint8Array':
-                return yield* Uint8Array(schema_, references_, value);
-            case 'Unknown':
-                return yield* Unknown(schema_, references_, value);
-            case 'Void':
-                return yield* Void(schema_, references_, value);
-            default:
-                if (!Types.TypeRegistry.Has(schema_[Types.Kind]))
-                    throw new TypeCompilerUnknownTypeError(schema);
-                return yield* UserDefined(schema_, references_, value);
-        }
-    }
-    // -------------------------------------------------------------------
-    // Compiler State
-    // -------------------------------------------------------------------
-    const state_local_variables = new Set(); // local variables and functions
-    const state_local_function_names = new Set(); // local function names used call ref validators
-    const state_remote_custom_types = new Map(); // remote custom types used during compilation
-    function ResetCompiler() {
-        state_local_variables.clear();
-        state_local_function_names.clear();
-        state_remote_custom_types.clear();
-    }
-    function CreateExpression(schema, references, value) {
-        return `(${[...Visit(schema, references, value)].join(' && ')})`;
-    }
-    function CreateFunctionName($id) {
-        return `check_${Identifier.Encode($id)}`;
-    }
-    function CreateFunction(name, schema, references, value) {
-        const expression = [...Visit(schema, references, value)].map((condition) => `    ${condition}`).join(' &&\n');
-        return `function ${name}(value) {\n  return (\n${expression}\n )\n}`;
-    }
-    function PushFunction(functionBody) {
-        state_local_variables.add(functionBody);
-    }
-    function PushLocal(expression) {
-        const local = `local_${state_local_variables.size}`;
-        state_local_variables.add(`const ${local} = ${expression}`);
-        return local;
-    }
-    function GetLocals() {
-        return [...state_local_variables.values()];
-    }
-    // -------------------------------------------------------------------
-    // Compile
-    // -------------------------------------------------------------------
-    function Build(schema, references) {
-        ResetCompiler();
-        const check = CreateFunction('check', schema, references, 'value');
-        const locals = GetLocals();
-        return `${locals.join('\n')}\nreturn ${check}`;
-    }
-    /** Returns the generated assertion code used to validate this type. */
-    function Code(schema, references = []) {
-        if (!Types.TypeGuard.TSchema(schema))
-            throw new TypeCompilerTypeGuardError(schema);
-        for (const schema of references)
-            if (!Types.TypeGuard.TSchema(schema))
-                throw new TypeCompilerTypeGuardError(schema);
-        return Build(schema, references);
-    }
-    TypeCompiler.Code = Code;
-    /** Compiles the given type for runtime type checking. This compiler only accepts known TypeBox types non-inclusive of unsafe types. */
-    function Compile(schema, references = []) {
-        const code = Code(schema, references);
-        const custom_schemas = new Map(state_remote_custom_types);
-        const compiledFunction = globalThis.Function('custom', 'format', 'hash', code);
-        const checkFunction = compiledFunction((kind, schema_key, value) => {
-            if (!Types.TypeRegistry.Has(kind) || !custom_schemas.has(schema_key))
-                return false;
-            const schema = custom_schemas.get(schema_key);
-            const func = Types.TypeRegistry.Get(kind);
-            return func(schema, value);
-        }, (format, value) => {
-            if (!Types.FormatRegistry.Has(format))
-                return false;
-            const func = Types.FormatRegistry.Get(format);
-            return func(value);
-        }, (value) => {
-            return hash_1.ValueHash.Create(value);
-        });
-        return new TypeCheck(schema, references, checkFunction, code);
-    }
-    TypeCompiler.Compile = Compile;
-})(TypeCompiler = exports.TypeCompiler || (exports.TypeCompiler = {}));

package/packages/plugin-devops/node_modules/@sinclair/typebox/compiler/index.d.ts

@@ -1,2 +0,0 @@
-export { ValueError, ValueErrorType } from '../errors/index';
-export * from './compiler';