@highstate/designer 0.2.1 → 0.2.2

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

@@ -1,66 +0,0 @@
-import { CreateType } from '../create/type.mjs';
-import { Discard } from '../discard/discard.mjs';
-import { Computed } from '../computed/index.mjs';
-import { Intersect } from '../intersect/index.mjs';
-import { Literal } from '../literal/index.mjs';
-import { Object } from '../object/index.mjs';
-import { Union } from '../union/index.mjs';
-import { IndexPropertyKeys } from '../indexed/index.mjs';
-import { TransformKind } from '../symbols/symbols.mjs';
-// ------------------------------------------------------------------
-// Guards
-// ------------------------------------------------------------------
-import { IsMappedKey, IsMappedResult, IsIntersect, IsUnion, IsObject, IsSchema, IsLiteralValue, IsRef } from '../guard/kind.mjs';
-import { IsArray as IsArrayValue } from '../guard/value.mjs';
-// ------------------------------------------------------------------
-// Infrastructure
-// ------------------------------------------------------------------
-import { PickFromMappedKey } from './pick-from-mapped-key.mjs';
-import { PickFromMappedResult } from './pick-from-mapped-result.mjs';
-function FromIntersect(types, propertyKeys) {
-    return types.map((type) => PickResolve(type, propertyKeys));
-}
-// prettier-ignore
-function FromUnion(types, propertyKeys) {
-    return types.map((type) => PickResolve(type, propertyKeys));
-}
-// prettier-ignore
-function FromProperties(properties, propertyKeys) {
-    const result = {};
-    for (const K2 of propertyKeys)
-        if (K2 in properties)
-            result[K2] = properties[K2];
-    return result;
-}
-// prettier-ignore
-function FromObject(T, K) {
-    const options = Discard(T, [TransformKind, '$id', 'required', 'properties']);
-    const properties = FromProperties(T['properties'], K);
-    return Object(properties, options);
-}
-// prettier-ignore
-function UnionFromPropertyKeys(propertyKeys) {
-    const result = propertyKeys.reduce((result, key) => IsLiteralValue(key) ? [...result, Literal(key)] : result, []);
-    return Union(result);
-}
-// prettier-ignore
-function PickResolve(properties, propertyKeys) {
-    return (IsIntersect(properties) ? Intersect(FromIntersect(properties.allOf, propertyKeys)) :
-        IsUnion(properties) ? Union(FromUnion(properties.anyOf, propertyKeys)) :
-            IsObject(properties) ? FromObject(properties, propertyKeys) :
-                Object({}));
-}
-/** `[Json]` Constructs a type whose keys are picked from the given type */
-// prettier-ignore
-export function Pick(type, key, options) {
-    const typeKey = IsArrayValue(key) ? UnionFromPropertyKeys(key) : key;
-    const propertyKeys = IsSchema(key) ? IndexPropertyKeys(key) : key;
-    const isTypeRef = IsRef(type);
-    const isKeyRef = IsRef(key);
-    return (IsMappedResult(type) ? PickFromMappedResult(type, propertyKeys, options) :
-        IsMappedKey(key) ? PickFromMappedKey(type, key, options) :
-            (isTypeRef && isKeyRef) ? Computed('Pick', [type, typeKey], options) :
-                (!isTypeRef && isKeyRef) ? Computed('Pick', [type, typeKey], options) :
-                    (isTypeRef && !isKeyRef) ? Computed('Pick', [type, typeKey], options) :
-                        CreateType({ ...PickResolve(type, propertyKeys), ...options }));
-}

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

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

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

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

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

@@ -1,2 +0,0 @@
-export * from './readonly-from-mapped-result.mjs';
-export * from './readonly.mjs';

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

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

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

@@ -1,22 +0,0 @@
-import { CreateType } from '../create/type.mjs';
-import { ReadonlyKind } from '../symbols/index.mjs';
-import { Discard } from '../discard/index.mjs';
-import { ReadonlyFromMappedResult } from './readonly-from-mapped-result.mjs';
-import { IsMappedResult } from '../guard/kind.mjs';
-function RemoveReadonly(schema) {
-    return CreateType(Discard(schema, [ReadonlyKind]));
-}
-function AddReadonly(schema) {
-    return CreateType({ ...schema, [ReadonlyKind]: 'Readonly' });
-}
-// prettier-ignore
-function ReadonlyWithFlag(schema, F) {
-    return (F === false
-        ? RemoveReadonly(schema)
-        : AddReadonly(schema));
-}
-/** `[Json]` Creates a Readonly property */
-export function Readonly(schema, enable) {
-    const F = enable ?? true;
-    return IsMappedResult(schema) ? ReadonlyFromMappedResult(schema, F) : ReadonlyWithFlag(schema, F);
-}

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/readonly-optional/index.mjs

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

package/.output/server/node_modules/@sinclair/typebox/build/esm/type/readonly-optional/readonly-optional.mjs

@@ -1,6 +0,0 @@
-import { Readonly } from '../readonly/index.mjs';
-import { Optional } from '../optional/index.mjs';
-/** `[Json]` Creates a Readonly and Optional property */
-export function ReadonlyOptional(schema) {
-    return Readonly(Optional(schema));
-}

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

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

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

@@ -1,94 +0,0 @@
-import { CreateType } from '../create/type.mjs';
-import { Kind, Hint } from '../symbols/index.mjs';
-import { Computed } from '../computed/index.mjs';
-import { Never } from '../never/index.mjs';
-import { Object } from '../object/index.mjs';
-import { Ref } from '../ref/index.mjs';
-import { Union } from '../union/index.mjs';
-import { IsTemplateLiteralFinite } from '../template-literal/index.mjs';
-import { PatternStringExact, PatternNumberExact, PatternNeverExact } from '../patterns/index.mjs';
-import { IndexPropertyKeys } from '../indexed/index.mjs';
-// ------------------------------------------------------------------
-// ValueGuard
-// ------------------------------------------------------------------
-import { IsUndefined } from '../guard/value.mjs';
-// ------------------------------------------------------------------
-// TypeGuard
-// ------------------------------------------------------------------
-import { IsInteger, IsLiteral, IsAny, IsNever, IsNumber, IsString, IsRegExp, IsTemplateLiteral, IsUnion, IsRef, IsComputed } from '../guard/kind.mjs';
-// ------------------------------------------------------------------
-// RecordCreateFromPattern
-// ------------------------------------------------------------------
-// prettier-ignore
-function RecordCreateFromPattern(pattern, T, options) {
-    return CreateType({ [Kind]: 'Record', type: 'object', patternProperties: { [pattern]: T } }, options);
-}
-// ------------------------------------------------------------------
-// RecordCreateFromKeys
-// ------------------------------------------------------------------
-// prettier-ignore
-function RecordCreateFromKeys(K, T, options) {
-    const result = {};
-    for (const K2 of K)
-        result[K2] = T;
-    return Object(result, { ...options, [Hint]: 'Record' });
-}
-// prettier-ignore
-function FromTemplateLiteralKey(K, T, options) {
-    return (IsTemplateLiteralFinite(K)
-        ? RecordCreateFromKeys(IndexPropertyKeys(K), T, options)
-        : RecordCreateFromPattern(K.pattern, T, options));
-}
-// prettier-ignore
-function FromUnionKey(key, type, options) {
-    return RecordCreateFromKeys(IndexPropertyKeys(Union(key)), type, options);
-}
-// prettier-ignore
-function FromLiteralKey(key, type, options) {
-    return RecordCreateFromKeys([key.toString()], type, options);
-}
-// prettier-ignore
-function FromRegExpKey(key, type, options) {
-    return RecordCreateFromPattern(key.source, type, options);
-}
-// prettier-ignore
-function FromStringKey(key, type, options) {
-    const pattern = IsUndefined(key.pattern) ? PatternStringExact : key.pattern;
-    return RecordCreateFromPattern(pattern, type, options);
-}
-// prettier-ignore
-function FromAnyKey(_, type, options) {
-    return RecordCreateFromPattern(PatternStringExact, type, options);
-}
-// prettier-ignore
-function FromNeverKey(_key, type, options) {
-    return RecordCreateFromPattern(PatternNeverExact, type, options);
-}
-// prettier-ignore
-function FromIntegerKey(_key, type, options) {
-    return RecordCreateFromPattern(PatternNumberExact, type, options);
-}
-// prettier-ignore
-function FromNumberKey(_, type, options) {
-    return RecordCreateFromPattern(PatternNumberExact, type, options);
-}
-// ------------------------------------------------------------------
-// TRecordOrObject
-// ------------------------------------------------------------------
-/** `[Json]` Creates a Record type */
-export function Record(key, type, options = {}) {
-    // prettier-ignore
-    return (IsComputed(type) ? Computed('Record', [key, Computed(type.target, type.parameters)], options) :
-        IsComputed(key) ? Computed('Record', [Computed(type.target, type.parameters), type], options) :
-            IsRef(key) ? Computed('Record', [Ref(key.$ref), type]) :
-                IsUnion(key) ? FromUnionKey(key.anyOf, type, options) :
-                    IsTemplateLiteral(key) ? FromTemplateLiteralKey(key, type, options) :
-                        IsLiteral(key) ? FromLiteralKey(key.const, type, options) :
-                            IsInteger(key) ? FromIntegerKey(key, type, options) :
-                                IsNumber(key) ? FromNumberKey(key, type, options) :
-                                    IsRegExp(key) ? FromRegExpKey(key, type, options) :
-                                        IsString(key) ? FromStringKey(key, type, options) :
-                                            IsAny(key) ? FromAnyKey(key, type, options) :
-                                                IsNever(key) ? FromNeverKey(key, type, options) :
-                                                    Never(options));
-}

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

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

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

@@ -1,15 +0,0 @@
-import { CloneType } from '../clone/type.mjs';
-import { CreateType } from '../create/type.mjs';
-import { IsUndefined } from '../guard/value.mjs';
-import { Kind, Hint } from '../symbols/index.mjs';
-// Auto Tracked For Recursive Types without ID's
-let Ordinal = 0;
-/** `[Json]` Creates a Recursive type */
-export function Recursive(callback, options = {}) {
-    if (IsUndefined(options.$id))
-        options.$id = `T${Ordinal++}`;
-    const thisType = CloneType(callback({ [Kind]: 'This', $ref: `${options.$id}` }));
-    thisType.$id = options.$id;
-    // prettier-ignore
-    return CreateType({ [Hint]: 'Recursive', ...thisType }, options);
-}

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

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

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

@@ -1,10 +0,0 @@
-import { TypeBoxError } from '../error/index.mjs';
-import { CreateType } from '../create/type.mjs';
-import { Kind } from '../symbols/index.mjs';
-/** `[Json]` Creates a Ref type. The referenced type must contain a $id */
-export function Ref(...args) {
-    const [$ref, options] = typeof args[0] === 'string' ? [args[0], args[1]] : [args[0].$id, args[1]];
-    if (typeof $ref !== 'string')
-        throw new TypeBoxError('Ref: $ref must be a string');
-    return CreateType({ [Kind]: 'Ref', $ref }, options);
-}

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

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

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

@@ -1,8 +0,0 @@
-import { CreateType } from '../create/type.mjs';
-import { IsString } from '../guard/value.mjs';
-import { Kind } from '../symbols/index.mjs';
-/** `[JavaScript]` Creates a RegExp type */
-export function RegExp(unresolved, options) {
-    const expr = IsString(unresolved) ? new globalThis.RegExp(unresolved) : unresolved;
-    return CreateType({ [Kind]: 'RegExp', type: 'RegExp', source: expr.source, flags: expr.flags }, options);
-}

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

@@ -1,26 +0,0 @@
-/** A registry for user defined string formats */
-const map = new Map();
-/** Returns the entries in this registry */
-export function Entries() {
-    return new Map(map);
-}
-/** Clears all user defined string formats */
-export function Clear() {
-    return map.clear();
-}
-/** Deletes a registered format */
-export function Delete(format) {
-    return map.delete(format);
-}
-/** Returns true if the user defined string format exists */
-export function Has(format) {
-    return map.has(format);
-}
-/** Sets a validation function for a user defined string format */
-export function Set(format, func) {
-    map.set(format, func);
-}
-/** Gets a validation function for a user defined string format */
-export function Get(format) {
-    return map.get(format);
-}

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

@@ -1,2 +0,0 @@
-export * as FormatRegistry from './format.mjs';
-export * as TypeRegistry from './type.mjs';

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

@@ -1,26 +0,0 @@
-/** A registry for user defined types */
-const map = new Map();
-/** Returns the entries in this registry */
-export function Entries() {
-    return new Map(map);
-}
-/** Clears all user defined types */
-export function Clear() {
-    return map.clear();
-}
-/** Deletes a registered type */
-export function Delete(kind) {
-    return map.delete(kind);
-}
-/** Returns true if this registry contains this kind */
-export function Has(kind) {
-    return map.has(kind);
-}
-/** Sets a validation function for a user defined type */
-export function Set(kind, func) {
-    map.set(kind, func);
-}
-/** Gets a custom validation function for a user defined type */
-export function Get(kind) {
-    return map.get(kind);
-}

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

@@ -1,2 +0,0 @@
-export * from './required-from-mapped-result.mjs';
-export * from './required.mjs';

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

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

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

@@ -1,60 +0,0 @@
-import { CreateType } from '../create/type.mjs';
-import { Computed } from '../computed/index.mjs';
-import { Object } from '../object/index.mjs';
-import { Intersect } from '../intersect/index.mjs';
-import { Union } from '../union/index.mjs';
-import { Ref } from '../ref/index.mjs';
-import { OptionalKind, TransformKind } from '../symbols/index.mjs';
-import { Discard } from '../discard/index.mjs';
-import { RequiredFromMappedResult } from './required-from-mapped-result.mjs';
-// ------------------------------------------------------------------
-// TypeGuard
-// ------------------------------------------------------------------
-import { IsMappedResult, IsIntersect, IsUnion, IsObject, IsRef, IsComputed } from '../guard/kind.mjs';
-// prettier-ignore
-function FromComputed(target, parameters) {
-    return Computed('Required', [Computed(target, parameters)]);
-}
-// prettier-ignore
-function FromRef($ref) {
-    return Computed('Required', [Ref($ref)]);
-}
-// prettier-ignore
-function FromProperties(properties) {
-    const requiredProperties = {};
-    for (const K of globalThis.Object.getOwnPropertyNames(properties))
-        requiredProperties[K] = Discard(properties[K], [OptionalKind]);
-    return requiredProperties;
-}
-// prettier-ignore
-function FromObject(type) {
-    const options = Discard(type, [TransformKind, '$id', 'required', 'properties']);
-    const properties = FromProperties(type['properties']);
-    return Object(properties, options);
-}
-// prettier-ignore
-function FromRest(types) {
-    return types.map(type => RequiredResolve(type));
-}
-// ------------------------------------------------------------------
-// RequiredResolve
-// ------------------------------------------------------------------
-// prettier-ignore
-function RequiredResolve(type) {
-    return (IsComputed(type) ? FromComputed(type.target, type.parameters) :
-        IsRef(type) ? FromRef(type.$ref) :
-            IsIntersect(type) ? Intersect(FromRest(type.allOf)) :
-                IsUnion(type) ? Union(FromRest(type.anyOf)) :
-                    IsObject(type) ? FromObject(type) :
-                        Object({}));
-}
-/** `[Json]` Constructs a type where all properties are required */
-export function Required(type, options) {
-    if (IsMappedResult(type)) {
-        return RequiredFromMappedResult(type, options);
-    }
-    else {
-        // special: mapping types require overridable options
-        return CreateType({ ...RequiredResolve(type), ...options });
-    }
-}

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

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

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

@@ -1,15 +0,0 @@
-// ------------------------------------------------------------------
-// TypeGuard
-// ------------------------------------------------------------------
-import { IsIntersect, IsUnion, IsTuple } from '../guard/kind.mjs';
-// prettier-ignore
-function RestResolve(T) {
-    return (IsIntersect(T) ? T.allOf :
-        IsUnion(T) ? T.anyOf :
-            IsTuple(T) ? T.items ?? [] :
-                []);
-}
-/** `[Json]` Extracts interior Rest elements from Tuple, Intersect and Union types */
-export function Rest(T) {
-    return RestResolve(T);
-}

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

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

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

@@ -1,5 +0,0 @@
-import { CreateType } from '../create/type.mjs';
-/** `[JavaScript]` Extracts the ReturnType from the given Function type */
-export function ReturnType(schema, options) {
-    return CreateType(schema.returns, options);
-}

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

@@ -1 +0,0 @@
-export {};

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

@@ -1,2 +0,0 @@
-export * from './anyschema.mjs';
-export * from './schema.mjs';

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

@@ -1 +0,0 @@
-import { Kind, Hint, ReadonlyKind, OptionalKind } from '../symbols/index.mjs';

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

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

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

@@ -1,48 +0,0 @@
-/** Returns true if element right is in the set of left */
-// prettier-ignore
-export function SetIncludes(T, S) {
-    return T.includes(S);
-}
-/** Returns true if left is a subset of right */
-export function SetIsSubset(T, S) {
-    return T.every((L) => SetIncludes(S, L));
-}
-/** Returns a distinct set of elements */
-export function SetDistinct(T) {
-    return [...new Set(T)];
-}
-/** Returns the Intersect of the given sets */
-export function SetIntersect(T, S) {
-    return T.filter((L) => S.includes(L));
-}
-/** Returns the Union of the given sets */
-export function SetUnion(T, S) {
-    return [...T, ...S];
-}
-/** Returns the Complement by omitting elements in T that are in S */
-// prettier-ignore
-export function SetComplement(T, S) {
-    return T.filter(L => !S.includes(L));
-}
-// prettier-ignore
-function SetIntersectManyResolve(T, Init) {
-    return T.reduce((Acc, L) => {
-        return SetIntersect(Acc, L);
-    }, Init);
-}
-// prettier-ignore
-export function SetIntersectMany(T) {
-    return (T.length === 1
-        ? T[0]
-        // Use left to initialize the accumulator for resolve
-        : T.length > 1
-            ? SetIntersectManyResolve(T.slice(1), T[0])
-            : []);
-}
-/** Returns the Union of multiple sets */
-export function SetUnionMany(T) {
-    const Acc = [];
-    for (const L of T)
-        Acc.push(...L);
-    return Acc;
-}

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

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

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

@@ -1 +0,0 @@
-export {};

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

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

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

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

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

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

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

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

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

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

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

@@ -1,10 +0,0 @@
-/** Symbol key applied to transform types */
-export const TransformKind = Symbol.for('TypeBox.Transform');
-/** Symbol key applied to readonly types */
-export const ReadonlyKind = Symbol.for('TypeBox.Readonly');
-/** Symbol key applied to optional types */
-export const OptionalKind = Symbol.for('TypeBox.Optional');
-/** Symbol key applied to types */
-export const Hint = Symbol.for('TypeBox.Hint');
-/** Symbol key applied to types */
-export const Kind = Symbol.for('TypeBox.Kind');

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

@@ -1,49 +0,0 @@
-import { TemplateLiteralParseExact } from './parse.mjs';
-import { TypeBoxError } from '../error/index.mjs';
-// ------------------------------------------------------------------
-// TemplateLiteralFiniteError
-// ------------------------------------------------------------------
-export class TemplateLiteralFiniteError extends TypeBoxError {
-}
-// ------------------------------------------------------------------
-// IsTemplateLiteralFiniteCheck
-// ------------------------------------------------------------------
-// prettier-ignore
-function IsNumberExpression(expression) {
-    return (expression.type === 'or' &&
-        expression.expr.length === 2 &&
-        expression.expr[0].type === 'const' &&
-        expression.expr[0].const === '0' &&
-        expression.expr[1].type === 'const' &&
-        expression.expr[1].const === '[1-9][0-9]*');
-}
-// prettier-ignore
-function IsBooleanExpression(expression) {
-    return (expression.type === 'or' &&
-        expression.expr.length === 2 &&
-        expression.expr[0].type === 'const' &&
-        expression.expr[0].const === 'true' &&
-        expression.expr[1].type === 'const' &&
-        expression.expr[1].const === 'false');
-}
-// prettier-ignore
-function IsStringExpression(expression) {
-    return expression.type === 'const' && expression.const === '.*';
-}
-// ------------------------------------------------------------------
-// IsTemplateLiteralExpressionFinite
-// ------------------------------------------------------------------
-// prettier-ignore
-export function IsTemplateLiteralExpressionFinite(expression) {
-    return (IsNumberExpression(expression) || IsStringExpression(expression) ? false :
-        IsBooleanExpression(expression) ? true :
-            (expression.type === 'and') ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) :
-                (expression.type === 'or') ? expression.expr.every((expr) => IsTemplateLiteralExpressionFinite(expr)) :
-                    (expression.type === 'const') ? true :
-                        (() => { throw new TemplateLiteralFiniteError(`Unknown expression type`); })());
-}
-/** Returns true if this TemplateLiteral resolves to a finite set of values */
-export function IsTemplateLiteralFinite(schema) {
-    const expression = TemplateLiteralParseExact(schema.pattern);
-    return IsTemplateLiteralExpressionFinite(expression);
-}