@highstate/designer 0.4.5 → 0.4.6

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/extends/extends-from-mapped-result.mjs

@@ -1,19 +0,0 @@
-import { MappedResult } from '../mapped/index.mjs';
-import { Extends } from './extends.mjs';
-import { Clone } from '../clone/value.mjs';
-// prettier-ignore
-function FromProperties(P, Right, True, False, options) {
-    const Acc = {};
-    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
-        Acc[K2] = Extends(P[K2], Right, True, False, Clone(options));
-    return Acc;
-}
-// prettier-ignore
-function FromMappedResult(Left, Right, True, False, options) {
-    return FromProperties(Left.properties, Right, True, False, options);
-}
-// prettier-ignore
-export function ExtendsFromMappedResult(Left, Right, True, False, options) {
-    const P = FromMappedResult(Left, Right, True, False, options);
-    return MappedResult(P);
-}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/extends/extends-undefined.mjs

@@ -1,20 +0,0 @@
-import { Kind } from '../symbols/index.mjs';
-/** Fast undefined check used for properties of type undefined */
-function Intersect(schema) {
-    return schema.allOf.every((schema) => ExtendsUndefinedCheck(schema));
-}
-function Union(schema) {
-    return schema.anyOf.some((schema) => ExtendsUndefinedCheck(schema));
-}
-function Not(schema) {
-    return !ExtendsUndefinedCheck(schema.not);
-}
-/** Fast undefined check used for properties of type undefined */
-// prettier-ignore
-export function ExtendsUndefinedCheck(schema) {
-    return (schema[Kind] === 'Intersect' ? Intersect(schema) :
-        schema[Kind] === 'Union' ? Union(schema) :
-            schema[Kind] === 'Not' ? Not(schema) :
-                schema[Kind] === 'Undefined' ? true :
-                    false);
-}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/extends/extends.mjs

@@ -1,23 +0,0 @@
-import { CreateType } from '../create/type.mjs';
-import { Union } from '../union/index.mjs';
-import { ExtendsCheck, ExtendsResult } from './extends-check.mjs';
-import { ExtendsFromMappedKey } from './extends-from-mapped-key.mjs';
-import { ExtendsFromMappedResult } from './extends-from-mapped-result.mjs';
-// ------------------------------------------------------------------
-// TypeGuard
-// ------------------------------------------------------------------
-import { IsMappedKey, IsMappedResult } from '../guard/kind.mjs';
-// prettier-ignore
-function ExtendsResolve(left, right, trueType, falseType) {
-    const R = ExtendsCheck(left, right);
-    return (R === ExtendsResult.Union ? Union([trueType, falseType]) :
-        R === ExtendsResult.True ? trueType :
-            falseType);
-}
-/** `[Json]` Creates a Conditional type */
-export function Extends(L, R, T, F, options) {
-    // prettier-ignore
-    return (IsMappedResult(L) ? ExtendsFromMappedResult(L, R, T, F, options) :
-        IsMappedKey(L) ? CreateType(ExtendsFromMappedKey(L, R, T, F, options)) :
-            CreateType(ExtendsResolve(L, R, T, F), options));
-}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/extends/index.mjs

@@ -1,5 +0,0 @@
-export * from './extends-check.mjs';
-export * from './extends-from-mapped-key.mjs';
-export * from './extends-from-mapped-result.mjs';
-export * from './extends-undefined.mjs';
-export * from './extends.mjs';

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/extract/extract-from-mapped-result.mjs

@@ -1,18 +0,0 @@
-import { MappedResult } from '../mapped/index.mjs';
-import { Extract } from './extract.mjs';
-// prettier-ignore
-function FromProperties(P, T) {
-    const Acc = {};
-    for (const K2 of globalThis.Object.getOwnPropertyNames(P))
-        Acc[K2] = Extract(P[K2], T);
-    return Acc;
-}
-// prettier-ignore
-function FromMappedResult(R, T) {
-    return FromProperties(R.properties, T);
-}
-// prettier-ignore
-export function ExtractFromMappedResult(R, T) {
-    const P = FromMappedResult(R, T);
-    return MappedResult(P);
-}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/extract/extract-from-template-literal.mjs

@@ -1,5 +0,0 @@
-import { Extract } from './extract.mjs';
-import { TemplateLiteralToUnion } from '../template-literal/index.mjs';
-export function ExtractFromTemplateLiteral(L, R) {
-    return Extract(TemplateLiteralToUnion(L), R);
-}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/extract/extract.mjs

@@ -1,25 +0,0 @@
-import { CreateType } from '../create/type.mjs';
-import { Union } from '../union/index.mjs';
-import { Never } from '../never/index.mjs';
-import { ExtendsCheck, ExtendsResult } from '../extends/index.mjs';
-import { ExtractFromMappedResult } from './extract-from-mapped-result.mjs';
-import { ExtractFromTemplateLiteral } from './extract-from-template-literal.mjs';
-// ------------------------------------------------------------------
-// TypeGuard
-// ------------------------------------------------------------------
-import { IsMappedResult, IsTemplateLiteral, IsUnion } from '../guard/kind.mjs';
-function ExtractRest(L, R) {
-    const extracted = L.filter((inner) => ExtendsCheck(inner, R) !== ExtendsResult.False);
-    return extracted.length === 1 ? extracted[0] : Union(extracted);
-}
-/** `[Json]` Constructs a type by extracting from type all union members that are assignable to union */
-export function Extract(L, R, options) {
-    // overloads
-    if (IsTemplateLiteral(L))
-        return CreateType(ExtractFromTemplateLiteral(L, R), options);
-    if (IsMappedResult(L))
-        return CreateType(ExtractFromMappedResult(L, R), options);
-    // prettier-ignore
-    return CreateType(IsUnion(L) ? ExtractRest(L.anyOf, R) :
-        ExtendsCheck(L, R) !== ExtendsResult.False ? L : Never(), options);
-}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/extract/index.mjs

@@ -1,3 +0,0 @@
-export * from './extract-from-mapped-result.mjs';
-export * from './extract-from-template-literal.mjs';
-export * from './extract.mjs';

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/function/function.mjs

@@ -1,6 +0,0 @@
-import { CreateType } from '../create/type.mjs';
-import { Kind } from '../symbols/index.mjs';
-/** `[JavaScript]` Creates a Function type */
-export function Function(parameters, returns, options) {
-    return CreateType({ [Kind]: 'Function', type: 'Function', parameters, returns }, options);
-}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/function/index.mjs

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

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/guard/index.mjs

@@ -1,3 +0,0 @@
-export * as KindGuard from './kind.mjs';
-export * as TypeGuard from './type.mjs';
-export * as ValueGuard from './value.mjs';

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/guard/kind.mjs

@@ -1,235 +0,0 @@
-import * as ValueGuard from './value.mjs';
-import { Kind, Hint, TransformKind, ReadonlyKind, OptionalKind } from '../symbols/index.mjs';
-/** `[Kind-Only]` Returns true if this value has a Readonly symbol */
-export function IsReadonly(value) {
-    return ValueGuard.IsObject(value) && value[ReadonlyKind] === 'Readonly';
-}
-/** `[Kind-Only]` Returns true if this value has a Optional symbol */
-export function IsOptional(value) {
-    return ValueGuard.IsObject(value) && value[OptionalKind] === 'Optional';
-}
-/** `[Kind-Only]` Returns true if the given value is TAny */
-export function IsAny(value) {
-    return IsKindOf(value, 'Any');
-}
-/** `[Kind-Only]` Returns true if the given value is TArgument */
-export function IsArgument(value) {
-    return IsKindOf(value, 'Argument');
-}
-/** `[Kind-Only]` Returns true if the given value is TArray */
-export function IsArray(value) {
-    return IsKindOf(value, 'Array');
-}
-/** `[Kind-Only]` Returns true if the given value is TAsyncIterator */
-export function IsAsyncIterator(value) {
-    return IsKindOf(value, 'AsyncIterator');
-}
-/** `[Kind-Only]` Returns true if the given value is TBigInt */
-export function IsBigInt(value) {
-    return IsKindOf(value, 'BigInt');
-}
-/** `[Kind-Only]` Returns true if the given value is TBoolean */
-export function IsBoolean(value) {
-    return IsKindOf(value, 'Boolean');
-}
-/** `[Kind-Only]` Returns true if the given value is TComputed */
-export function IsComputed(value) {
-    return IsKindOf(value, 'Computed');
-}
-/** `[Kind-Only]` Returns true if the given value is TConstructor */
-export function IsConstructor(value) {
-    return IsKindOf(value, 'Constructor');
-}
-/** `[Kind-Only]` Returns true if the given value is TDate */
-export function IsDate(value) {
-    return IsKindOf(value, 'Date');
-}
-/** `[Kind-Only]` Returns true if the given value is TFunction */
-export function IsFunction(value) {
-    return IsKindOf(value, 'Function');
-}
-/** `[Kind-Only]` Returns true if the given value is TInteger */
-export function IsImport(value) {
-    return IsKindOf(value, 'Import');
-}
-/** `[Kind-Only]` Returns true if the given value is TInteger */
-export function IsInteger(value) {
-    return IsKindOf(value, 'Integer');
-}
-/** `[Kind-Only]` Returns true if the given schema is TProperties */
-export function IsProperties(value) {
-    return ValueGuard.IsObject(value);
-}
-/** `[Kind-Only]` Returns true if the given value is TIntersect */
-export function IsIntersect(value) {
-    return IsKindOf(value, 'Intersect');
-}
-/** `[Kind-Only]` Returns true if the given value is TIterator */
-export function IsIterator(value) {
-    return IsKindOf(value, 'Iterator');
-}
-/** `[Kind-Only]` Returns true if the given value is a TKind with the given name. */
-export function IsKindOf(value, kind) {
-    return ValueGuard.IsObject(value) && Kind in value && value[Kind] === kind;
-}
-/** `[Kind-Only]` Returns true if the given value is TLiteral<string> */
-export function IsLiteralString(value) {
-    return IsLiteral(value) && ValueGuard.IsString(value.const);
-}
-/** `[Kind-Only]` Returns true if the given value is TLiteral<number> */
-export function IsLiteralNumber(value) {
-    return IsLiteral(value) && ValueGuard.IsNumber(value.const);
-}
-/** `[Kind-Only]` Returns true if the given value is TLiteral<boolean> */
-export function IsLiteralBoolean(value) {
-    return IsLiteral(value) && ValueGuard.IsBoolean(value.const);
-}
-/** `[Kind-Only]` Returns true if the given value is TLiteralValue */
-export function IsLiteralValue(value) {
-    return ValueGuard.IsBoolean(value) || ValueGuard.IsNumber(value) || ValueGuard.IsString(value);
-}
-/** `[Kind-Only]` Returns true if the given value is TLiteral */
-export function IsLiteral(value) {
-    return IsKindOf(value, 'Literal');
-}
-/** `[Kind-Only]` Returns true if the given value is a TMappedKey */
-export function IsMappedKey(value) {
-    return IsKindOf(value, 'MappedKey');
-}
-/** `[Kind-Only]` Returns true if the given value is TMappedResult */
-export function IsMappedResult(value) {
-    return IsKindOf(value, 'MappedResult');
-}
-/** `[Kind-Only]` Returns true if the given value is TNever */
-export function IsNever(value) {
-    return IsKindOf(value, 'Never');
-}
-/** `[Kind-Only]` Returns true if the given value is TNot */
-export function IsNot(value) {
-    return IsKindOf(value, 'Not');
-}
-/** `[Kind-Only]` Returns true if the given value is TNull */
-export function IsNull(value) {
-    return IsKindOf(value, 'Null');
-}
-/** `[Kind-Only]` Returns true if the given value is TNumber */
-export function IsNumber(value) {
-    return IsKindOf(value, 'Number');
-}
-/** `[Kind-Only]` Returns true if the given value is TObject */
-export function IsObject(value) {
-    return IsKindOf(value, 'Object');
-}
-/** `[Kind-Only]` Returns true if the given value is TPromise */
-export function IsPromise(value) {
-    return IsKindOf(value, 'Promise');
-}
-/** `[Kind-Only]` Returns true if the given value is TRecord */
-export function IsRecord(value) {
-    return IsKindOf(value, 'Record');
-}
-/** `[Kind-Only]` Returns true if this value is TRecursive */
-export function IsRecursive(value) {
-    return ValueGuard.IsObject(value) && Hint in value && value[Hint] === 'Recursive';
-}
-/** `[Kind-Only]` Returns true if the given value is TRef */
-export function IsRef(value) {
-    return IsKindOf(value, 'Ref');
-}
-/** `[Kind-Only]` Returns true if the given value is TRegExp */
-export function IsRegExp(value) {
-    return IsKindOf(value, 'RegExp');
-}
-/** `[Kind-Only]` Returns true if the given value is TString */
-export function IsString(value) {
-    return IsKindOf(value, 'String');
-}
-/** `[Kind-Only]` Returns true if the given value is TSymbol */
-export function IsSymbol(value) {
-    return IsKindOf(value, 'Symbol');
-}
-/** `[Kind-Only]` Returns true if the given value is TTemplateLiteral */
-export function IsTemplateLiteral(value) {
-    return IsKindOf(value, 'TemplateLiteral');
-}
-/** `[Kind-Only]` Returns true if the given value is TThis */
-export function IsThis(value) {
-    return IsKindOf(value, 'This');
-}
-/** `[Kind-Only]` Returns true of this value is TTransform */
-export function IsTransform(value) {
-    return ValueGuard.IsObject(value) && TransformKind in value;
-}
-/** `[Kind-Only]` Returns true if the given value is TTuple */
-export function IsTuple(value) {
-    return IsKindOf(value, 'Tuple');
-}
-/** `[Kind-Only]` Returns true if the given value is TUndefined */
-export function IsUndefined(value) {
-    return IsKindOf(value, 'Undefined');
-}
-/** `[Kind-Only]` Returns true if the given value is TUnion */
-export function IsUnion(value) {
-    return IsKindOf(value, 'Union');
-}
-/** `[Kind-Only]` Returns true if the given value is TUint8Array */
-export function IsUint8Array(value) {
-    return IsKindOf(value, 'Uint8Array');
-}
-/** `[Kind-Only]` Returns true if the given value is TUnknown */
-export function IsUnknown(value) {
-    return IsKindOf(value, 'Unknown');
-}
-/** `[Kind-Only]` Returns true if the given value is a raw TUnsafe */
-export function IsUnsafe(value) {
-    return IsKindOf(value, 'Unsafe');
-}
-/** `[Kind-Only]` Returns true if the given value is TVoid */
-export function IsVoid(value) {
-    return IsKindOf(value, 'Void');
-}
-/** `[Kind-Only]` Returns true if the given value is TKind */
-export function IsKind(value) {
-    return ValueGuard.IsObject(value) && Kind in value && ValueGuard.IsString(value[Kind]);
-}
-/** `[Kind-Only]` Returns true if the given value is TSchema */
-export function IsSchema(value) {
-    // prettier-ignore
-    return (IsAny(value) ||
-        IsArgument(value) ||
-        IsArray(value) ||
-        IsBoolean(value) ||
-        IsBigInt(value) ||
-        IsAsyncIterator(value) ||
-        IsComputed(value) ||
-        IsConstructor(value) ||
-        IsDate(value) ||
-        IsFunction(value) ||
-        IsInteger(value) ||
-        IsIntersect(value) ||
-        IsIterator(value) ||
-        IsLiteral(value) ||
-        IsMappedKey(value) ||
-        IsMappedResult(value) ||
-        IsNever(value) ||
-        IsNot(value) ||
-        IsNull(value) ||
-        IsNumber(value) ||
-        IsObject(value) ||
-        IsPromise(value) ||
-        IsRecord(value) ||
-        IsRef(value) ||
-        IsRegExp(value) ||
-        IsString(value) ||
-        IsSymbol(value) ||
-        IsTemplateLiteral(value) ||
-        IsThis(value) ||
-        IsTuple(value) ||
-        IsUndefined(value) ||
-        IsUnion(value) ||
-        IsUint8Array(value) ||
-        IsUnknown(value) ||
-        IsUnsafe(value) ||
-        IsVoid(value) ||
-        IsKind(value));
-}