@highstate/designer 0.4.5 → 0.4.6

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

@@ -1,509 +0,0 @@
-import * as ValueGuard from './value.mjs';
-import { Kind, Hint, TransformKind, ReadonlyKind, OptionalKind } from '../symbols/index.mjs';
-import { TypeBoxError } from '../error/index.mjs';
-export class TypeGuardUnknownTypeError extends TypeBoxError {
-}
-const KnownTypes = [
-    'Argument',
-    'Any',
-    'Array',
-    'AsyncIterator',
-    'BigInt',
-    'Boolean',
-    'Computed',
-    'Constructor',
-    'Date',
-    'Enum',
-    'Function',
-    'Integer',
-    'Intersect',
-    'Iterator',
-    'Literal',
-    'MappedKey',
-    'MappedResult',
-    'Not',
-    'Null',
-    'Number',
-    'Object',
-    'Promise',
-    'Record',
-    'Ref',
-    'RegExp',
-    'String',
-    'Symbol',
-    'TemplateLiteral',
-    'This',
-    'Tuple',
-    'Undefined',
-    'Union',
-    'Uint8Array',
-    'Unknown',
-    'Void',
-];
-function IsPattern(value) {
-    try {
-        new RegExp(value);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function IsControlCharacterFree(value) {
-    if (!ValueGuard.IsString(value))
-        return false;
-    for (let i = 0; i < value.length; i++) {
-        const code = value.charCodeAt(i);
-        if ((code >= 7 && code <= 13) || code === 27 || code === 127) {
-            return false;
-        }
-    }
-    return true;
-}
-function IsAdditionalProperties(value) {
-    return IsOptionalBoolean(value) || IsSchema(value);
-}
-function IsOptionalBigInt(value) {
-    return ValueGuard.IsUndefined(value) || ValueGuard.IsBigInt(value);
-}
-function IsOptionalNumber(value) {
-    return ValueGuard.IsUndefined(value) || ValueGuard.IsNumber(value);
-}
-function IsOptionalBoolean(value) {
-    return ValueGuard.IsUndefined(value) || ValueGuard.IsBoolean(value);
-}
-function IsOptionalString(value) {
-    return ValueGuard.IsUndefined(value) || ValueGuard.IsString(value);
-}
-function IsOptionalPattern(value) {
-    return ValueGuard.IsUndefined(value) || (ValueGuard.IsString(value) && IsControlCharacterFree(value) && IsPattern(value));
-}
-function IsOptionalFormat(value) {
-    return ValueGuard.IsUndefined(value) || (ValueGuard.IsString(value) && IsControlCharacterFree(value));
-}
-function IsOptionalSchema(value) {
-    return ValueGuard.IsUndefined(value) || IsSchema(value);
-}
-// ------------------------------------------------------------------
-// Modifiers
-// ------------------------------------------------------------------
-/** Returns true if this value has a Readonly symbol */
-export function IsReadonly(value) {
-    return ValueGuard.IsObject(value) && value[ReadonlyKind] === 'Readonly';
-}
-/** Returns true if this value has a Optional symbol */
-export function IsOptional(value) {
-    return ValueGuard.IsObject(value) && value[OptionalKind] === 'Optional';
-}
-// ------------------------------------------------------------------
-// Types
-// ------------------------------------------------------------------
-/** Returns true if the given value is TAny */
-export function IsAny(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'Any') &&
-        IsOptionalString(value.$id));
-}
-/** Returns true if the given value is TArgument */
-export function IsArgument(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'Argument') &&
-        ValueGuard.IsNumber(value.index));
-}
-/** Returns true if the given value is TArray */
-export function IsArray(value) {
-    return (IsKindOf(value, 'Array') &&
-        value.type === 'array' &&
-        IsOptionalString(value.$id) &&
-        IsSchema(value.items) &&
-        IsOptionalNumber(value.minItems) &&
-        IsOptionalNumber(value.maxItems) &&
-        IsOptionalBoolean(value.uniqueItems) &&
-        IsOptionalSchema(value.contains) &&
-        IsOptionalNumber(value.minContains) &&
-        IsOptionalNumber(value.maxContains));
-}
-/** Returns true if the given value is TAsyncIterator */
-export function IsAsyncIterator(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'AsyncIterator') &&
-        value.type === 'AsyncIterator' &&
-        IsOptionalString(value.$id) &&
-        IsSchema(value.items));
-}
-/** Returns true if the given value is TBigInt */
-export function IsBigInt(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'BigInt') &&
-        value.type === 'bigint' &&
-        IsOptionalString(value.$id) &&
-        IsOptionalBigInt(value.exclusiveMaximum) &&
-        IsOptionalBigInt(value.exclusiveMinimum) &&
-        IsOptionalBigInt(value.maximum) &&
-        IsOptionalBigInt(value.minimum) &&
-        IsOptionalBigInt(value.multipleOf));
-}
-/** Returns true if the given value is TBoolean */
-export function IsBoolean(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'Boolean') &&
-        value.type === 'boolean' &&
-        IsOptionalString(value.$id));
-}
-/** Returns true if the given value is TComputed */
-export function IsComputed(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'Computed') &&
-        ValueGuard.IsString(value.target) &&
-        ValueGuard.IsArray(value.parameters) &&
-        value.parameters.every((schema) => IsSchema(schema)));
-}
-/** Returns true if the given value is TConstructor */
-export function IsConstructor(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'Constructor') &&
-        value.type === 'Constructor' &&
-        IsOptionalString(value.$id) &&
-        ValueGuard.IsArray(value.parameters) &&
-        value.parameters.every(schema => IsSchema(schema)) &&
-        IsSchema(value.returns));
-}
-/** Returns true if the given value is TDate */
-export function IsDate(value) {
-    return (IsKindOf(value, 'Date') &&
-        value.type === 'Date' &&
-        IsOptionalString(value.$id) &&
-        IsOptionalNumber(value.exclusiveMaximumTimestamp) &&
-        IsOptionalNumber(value.exclusiveMinimumTimestamp) &&
-        IsOptionalNumber(value.maximumTimestamp) &&
-        IsOptionalNumber(value.minimumTimestamp) &&
-        IsOptionalNumber(value.multipleOfTimestamp));
-}
-/** Returns true if the given value is TFunction */
-export function IsFunction(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'Function') &&
-        value.type === 'Function' &&
-        IsOptionalString(value.$id) &&
-        ValueGuard.IsArray(value.parameters) &&
-        value.parameters.every(schema => IsSchema(schema)) &&
-        IsSchema(value.returns));
-}
-/** Returns true if the given value is TImport */
-export function IsImport(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'Import') &&
-        ValueGuard.HasPropertyKey(value, '$defs') &&
-        ValueGuard.IsObject(value.$defs) &&
-        IsProperties(value.$defs) &&
-        ValueGuard.HasPropertyKey(value, '$ref') &&
-        ValueGuard.IsString(value.$ref) &&
-        value.$ref in value.$defs // required
-    );
-}
-/** Returns true if the given value is TInteger */
-export function IsInteger(value) {
-    return (IsKindOf(value, 'Integer') &&
-        value.type === 'integer' &&
-        IsOptionalString(value.$id) &&
-        IsOptionalNumber(value.exclusiveMaximum) &&
-        IsOptionalNumber(value.exclusiveMinimum) &&
-        IsOptionalNumber(value.maximum) &&
-        IsOptionalNumber(value.minimum) &&
-        IsOptionalNumber(value.multipleOf));
-}
-/** Returns true if the given schema is TProperties */
-export function IsProperties(value) {
-    // prettier-ignore
-    return (ValueGuard.IsObject(value) &&
-        Object.entries(value).every(([key, schema]) => IsControlCharacterFree(key) && IsSchema(schema)));
-}
-/** Returns true if the given value is TIntersect */
-export function IsIntersect(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'Intersect') &&
-        (ValueGuard.IsString(value.type) && value.type !== 'object' ? false : true) &&
-        ValueGuard.IsArray(value.allOf) &&
-        value.allOf.every(schema => IsSchema(schema) && !IsTransform(schema)) &&
-        IsOptionalString(value.type) &&
-        (IsOptionalBoolean(value.unevaluatedProperties) || IsOptionalSchema(value.unevaluatedProperties)) &&
-        IsOptionalString(value.$id));
-}
-/** Returns true if the given value is TIterator */
-export function IsIterator(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'Iterator') &&
-        value.type === 'Iterator' &&
-        IsOptionalString(value.$id) &&
-        IsSchema(value.items));
-}
-/** 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;
-}
-/** Returns true if the given value is TLiteral<string> */
-export function IsLiteralString(value) {
-    return IsLiteral(value) && ValueGuard.IsString(value.const);
-}
-/** Returns true if the given value is TLiteral<number> */
-export function IsLiteralNumber(value) {
-    return IsLiteral(value) && ValueGuard.IsNumber(value.const);
-}
-/** Returns true if the given value is TLiteral<boolean> */
-export function IsLiteralBoolean(value) {
-    return IsLiteral(value) && ValueGuard.IsBoolean(value.const);
-}
-/** Returns true if the given value is TLiteral */
-export function IsLiteral(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'Literal') &&
-        IsOptionalString(value.$id) && IsLiteralValue(value.const));
-}
-/** Returns true if the given value is a TLiteralValue */
-export function IsLiteralValue(value) {
-    return ValueGuard.IsBoolean(value) || ValueGuard.IsNumber(value) || ValueGuard.IsString(value);
-}
-/** Returns true if the given value is a TMappedKey */
-export function IsMappedKey(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'MappedKey') &&
-        ValueGuard.IsArray(value.keys) &&
-        value.keys.every(key => ValueGuard.IsNumber(key) || ValueGuard.IsString(key)));
-}
-/** Returns true if the given value is TMappedResult */
-export function IsMappedResult(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'MappedResult') &&
-        IsProperties(value.properties));
-}
-/** Returns true if the given value is TNever */
-export function IsNever(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'Never') &&
-        ValueGuard.IsObject(value.not) &&
-        Object.getOwnPropertyNames(value.not).length === 0);
-}
-/** Returns true if the given value is TNot */
-export function IsNot(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'Not') &&
-        IsSchema(value.not));
-}
-/** Returns true if the given value is TNull */
-export function IsNull(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'Null') &&
-        value.type === 'null' &&
-        IsOptionalString(value.$id));
-}
-/** Returns true if the given value is TNumber */
-export function IsNumber(value) {
-    return (IsKindOf(value, 'Number') &&
-        value.type === 'number' &&
-        IsOptionalString(value.$id) &&
-        IsOptionalNumber(value.exclusiveMaximum) &&
-        IsOptionalNumber(value.exclusiveMinimum) &&
-        IsOptionalNumber(value.maximum) &&
-        IsOptionalNumber(value.minimum) &&
-        IsOptionalNumber(value.multipleOf));
-}
-/** Returns true if the given value is TObject */
-export function IsObject(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'Object') &&
-        value.type === 'object' &&
-        IsOptionalString(value.$id) &&
-        IsProperties(value.properties) &&
-        IsAdditionalProperties(value.additionalProperties) &&
-        IsOptionalNumber(value.minProperties) &&
-        IsOptionalNumber(value.maxProperties));
-}
-/** Returns true if the given value is TPromise */
-export function IsPromise(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'Promise') &&
-        value.type === 'Promise' &&
-        IsOptionalString(value.$id) &&
-        IsSchema(value.item));
-}
-/** Returns true if the given value is TRecord */
-export function IsRecord(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'Record') &&
-        value.type === 'object' &&
-        IsOptionalString(value.$id) &&
-        IsAdditionalProperties(value.additionalProperties) &&
-        ValueGuard.IsObject(value.patternProperties) &&
-        ((schema) => {
-            const keys = Object.getOwnPropertyNames(schema.patternProperties);
-            return (keys.length === 1 &&
-                IsPattern(keys[0]) &&
-                ValueGuard.IsObject(schema.patternProperties) &&
-                IsSchema(schema.patternProperties[keys[0]]));
-        })(value));
-}
-/** Returns true if this value is TRecursive */
-export function IsRecursive(value) {
-    return ValueGuard.IsObject(value) && Hint in value && value[Hint] === 'Recursive';
-}
-/** Returns true if the given value is TRef */
-export function IsRef(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'Ref') &&
-        IsOptionalString(value.$id) &&
-        ValueGuard.IsString(value.$ref));
-}
-/** Returns true if the given value is TRegExp */
-export function IsRegExp(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'RegExp') &&
-        IsOptionalString(value.$id) &&
-        ValueGuard.IsString(value.source) &&
-        ValueGuard.IsString(value.flags) &&
-        IsOptionalNumber(value.maxLength) &&
-        IsOptionalNumber(value.minLength));
-}
-/** Returns true if the given value is TString */
-export function IsString(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'String') &&
-        value.type === 'string' &&
-        IsOptionalString(value.$id) &&
-        IsOptionalNumber(value.minLength) &&
-        IsOptionalNumber(value.maxLength) &&
-        IsOptionalPattern(value.pattern) &&
-        IsOptionalFormat(value.format));
-}
-/** Returns true if the given value is TSymbol */
-export function IsSymbol(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'Symbol') &&
-        value.type === 'symbol' &&
-        IsOptionalString(value.$id));
-}
-/** Returns true if the given value is TTemplateLiteral */
-export function IsTemplateLiteral(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'TemplateLiteral') &&
-        value.type === 'string' &&
-        ValueGuard.IsString(value.pattern) &&
-        value.pattern[0] === '^' &&
-        value.pattern[value.pattern.length - 1] === '$');
-}
-/** Returns true if the given value is TThis */
-export function IsThis(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'This') &&
-        IsOptionalString(value.$id) &&
-        ValueGuard.IsString(value.$ref));
-}
-/** Returns true of this value is TTransform */
-export function IsTransform(value) {
-    return ValueGuard.IsObject(value) && TransformKind in value;
-}
-/** Returns true if the given value is TTuple */
-export function IsTuple(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'Tuple') &&
-        value.type === 'array' &&
-        IsOptionalString(value.$id) &&
-        ValueGuard.IsNumber(value.minItems) &&
-        ValueGuard.IsNumber(value.maxItems) &&
-        value.minItems === value.maxItems &&
-        (( // empty
-        ValueGuard.IsUndefined(value.items) &&
-            ValueGuard.IsUndefined(value.additionalItems) &&
-            value.minItems === 0) || (ValueGuard.IsArray(value.items) &&
-            value.items.every(schema => IsSchema(schema)))));
-}
-/** Returns true if the given value is TUndefined */
-export function IsUndefined(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'Undefined') &&
-        value.type === 'undefined' &&
-        IsOptionalString(value.$id));
-}
-/** Returns true if the given value is TUnion<Literal<string | number>[]> */
-export function IsUnionLiteral(value) {
-    return IsUnion(value) && value.anyOf.every((schema) => IsLiteralString(schema) || IsLiteralNumber(schema));
-}
-/** Returns true if the given value is TUnion */
-export function IsUnion(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'Union') &&
-        IsOptionalString(value.$id) &&
-        ValueGuard.IsObject(value) &&
-        ValueGuard.IsArray(value.anyOf) &&
-        value.anyOf.every(schema => IsSchema(schema)));
-}
-/** Returns true if the given value is TUint8Array */
-export function IsUint8Array(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'Uint8Array') &&
-        value.type === 'Uint8Array' &&
-        IsOptionalString(value.$id) &&
-        IsOptionalNumber(value.minByteLength) &&
-        IsOptionalNumber(value.maxByteLength));
-}
-/** Returns true if the given value is TUnknown */
-export function IsUnknown(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'Unknown') &&
-        IsOptionalString(value.$id));
-}
-/** Returns true if the given value is a raw TUnsafe */
-export function IsUnsafe(value) {
-    return IsKindOf(value, 'Unsafe');
-}
-/** Returns true if the given value is TVoid */
-export function IsVoid(value) {
-    // prettier-ignore
-    return (IsKindOf(value, 'Void') &&
-        value.type === 'void' &&
-        IsOptionalString(value.$id));
-}
-/** Returns true if the given value is TKind */
-export function IsKind(value) {
-    return ValueGuard.IsObject(value) && Kind in value && ValueGuard.IsString(value[Kind]) && !KnownTypes.includes(value[Kind]);
-}
-/** Returns true if the given value is TSchema */
-export function IsSchema(value) {
-    // prettier-ignore
-    return (ValueGuard.IsObject(value)) && (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));
-}

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

@@ -1,70 +0,0 @@
-// --------------------------------------------------------------------------
-// PropertyKey
-// --------------------------------------------------------------------------
-/** Returns true if this value has this property key */
-export function HasPropertyKey(value, key) {
-    return key in value;
-}
-// --------------------------------------------------------------------------
-// Object Instances
-// --------------------------------------------------------------------------
-/** Returns true if this value is an async iterator */
-export function IsAsyncIterator(value) {
-    return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.asyncIterator in value;
-}
-/** Returns true if this value is an array */
-export function IsArray(value) {
-    return Array.isArray(value);
-}
-/** Returns true if this value is bigint */
-export function IsBigInt(value) {
-    return typeof value === 'bigint';
-}
-/** Returns true if this value is a boolean */
-export function IsBoolean(value) {
-    return typeof value === 'boolean';
-}
-/** Returns true if this value is a Date object */
-export function IsDate(value) {
-    return value instanceof globalThis.Date;
-}
-/** Returns true if this value is a function */
-export function IsFunction(value) {
-    return typeof value === 'function';
-}
-/** Returns true if this value is an iterator */
-export function IsIterator(value) {
-    return IsObject(value) && !IsArray(value) && !IsUint8Array(value) && Symbol.iterator in value;
-}
-/** Returns true if this value is null */
-export function IsNull(value) {
-    return value === null;
-}
-/** Returns true if this value is number */
-export function IsNumber(value) {
-    return typeof value === 'number';
-}
-/** Returns true if this value is an object */
-export function IsObject(value) {
-    return typeof value === 'object' && value !== null;
-}
-/** Returns true if this value is RegExp */
-export function IsRegExp(value) {
-    return value instanceof globalThis.RegExp;
-}
-/** Returns true if this value is string */
-export function IsString(value) {
-    return typeof value === 'string';
-}
-/** Returns true if this value is symbol */
-export function IsSymbol(value) {
-    return typeof value === 'symbol';
-}
-/** Returns true if this value is a Uint8Array */
-export function IsUint8Array(value) {
-    return value instanceof globalThis.Uint8Array;
-}
-/** Returns true if this value is undefined */
-export function IsUndefined(value) {
-    return value === undefined;
-}

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

@@ -1,4 +0,0 @@
-/** Increments the given string value + 1 */
-export function Increment(T) {
-    return (parseInt(T) + 1).toString();
-}

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

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

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

@@ -1,4 +0,0 @@
-export * from './indexed-from-mapped-key.mjs';
-export * from './indexed-from-mapped-result.mjs';
-export * from './indexed-property-keys.mjs';
-export * from './indexed.mjs';

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

@@ -1,22 +0,0 @@
-import { Index } from './indexed.mjs';
-import { MappedResult } from '../mapped/index.mjs';
-import { Clone } from '../clone/value.mjs';
-// prettier-ignore
-function MappedIndexPropertyKey(type, key, options) {
-    return { [key]: Index(type, [key], Clone(options)) };
-}
-// prettier-ignore
-function MappedIndexPropertyKeys(type, propertyKeys, options) {
-    return propertyKeys.reduce((result, left) => {
-        return { ...result, ...MappedIndexPropertyKey(type, left, options) };
-    }, {});
-}
-// prettier-ignore
-function MappedIndexProperties(type, mappedKey, options) {
-    return MappedIndexPropertyKeys(type, mappedKey.keys, options);
-}
-// prettier-ignore
-export function IndexFromMappedKey(type, mappedKey, options) {
-    const properties = MappedIndexProperties(type, mappedKey, options);
-    return MappedResult(properties);
-}

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

@@ -1,20 +0,0 @@
-import { MappedResult } from '../mapped/index.mjs';
-import { IndexPropertyKeys } from './indexed-property-keys.mjs';
-import { Index } from './index.mjs';
-// prettier-ignore
-function FromProperties(type, properties, options) {
-    const result = {};
-    for (const K2 of Object.getOwnPropertyNames(properties)) {
-        result[K2] = Index(type, IndexPropertyKeys(properties[K2]), options);
-    }
-    return result;
-}
-// prettier-ignore
-function FromMappedResult(type, mappedResult, options) {
-    return FromProperties(type, mappedResult.properties, options);
-}
-// prettier-ignore
-export function IndexFromMappedResult(type, mappedResult, options) {
-    const properties = FromMappedResult(type, mappedResult, options);
-    return MappedResult(properties);
-}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/indexed/indexed-property-keys.mjs

@@ -1,32 +0,0 @@
-import { TemplateLiteralGenerate } from '../template-literal/index.mjs';
-// ------------------------------------------------------------------
-// TypeGuard
-// ------------------------------------------------------------------
-import { IsTemplateLiteral, IsUnion, IsLiteral, IsNumber, IsInteger } from '../guard/kind.mjs';
-// prettier-ignore
-function FromTemplateLiteral(templateLiteral) {
-    const keys = TemplateLiteralGenerate(templateLiteral);
-    return keys.map(key => key.toString());
-}
-// prettier-ignore
-function FromUnion(types) {
-    const result = [];
-    for (const type of types)
-        result.push(...IndexPropertyKeys(type));
-    return result;
-}
-// prettier-ignore
-function FromLiteral(literalValue) {
-    return ([literalValue.toString()] // TS 5.4 observes TLiteralValue as not having a toString()
-    );
-}
-/** Returns a tuple of PropertyKeys derived from the given TSchema */
-// prettier-ignore
-export function IndexPropertyKeys(type) {
-    return [...new Set((IsTemplateLiteral(type) ? FromTemplateLiteral(type) :
-            IsUnion(type) ? FromUnion(type.anyOf) :
-                IsLiteral(type) ? FromLiteral(type.const) :
-                    IsNumber(type) ? ['[number]'] :
-                        IsInteger(type) ? ['[number]'] :
-                            []))];
-}