@highstate/designer 0.2.1 → 0.2.2

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

@@ -1,53 +0,0 @@
-import { IsTemplateLiteralExpressionFinite } from './finite.mjs';
-import { TemplateLiteralParseExact } from './parse.mjs';
-import { TypeBoxError } from '../error/index.mjs';
-// ------------------------------------------------------------------
-// TemplateLiteralGenerateError
-// ------------------------------------------------------------------
-export class TemplateLiteralGenerateError extends TypeBoxError {
-}
-// ------------------------------------------------------------------
-// TemplateLiteralExpressionGenerate
-// ------------------------------------------------------------------
-// prettier-ignore
-function* GenerateReduce(buffer) {
-    if (buffer.length === 1)
-        return yield* buffer[0];
-    for (const left of buffer[0]) {
-        for (const right of GenerateReduce(buffer.slice(1))) {
-            yield `${left}${right}`;
-        }
-    }
-}
-// prettier-ignore
-function* GenerateAnd(expression) {
-    return yield* GenerateReduce(expression.expr.map((expr) => [...TemplateLiteralExpressionGenerate(expr)]));
-}
-// prettier-ignore
-function* GenerateOr(expression) {
-    for (const expr of expression.expr)
-        yield* TemplateLiteralExpressionGenerate(expr);
-}
-// prettier-ignore
-function* GenerateConst(expression) {
-    return yield expression.const;
-}
-export function* TemplateLiteralExpressionGenerate(expression) {
-    return expression.type === 'and'
-        ? yield* GenerateAnd(expression)
-        : expression.type === 'or'
-            ? yield* GenerateOr(expression)
-            : expression.type === 'const'
-                ? yield* GenerateConst(expression)
-                : (() => {
-                    throw new TemplateLiteralGenerateError('Unknown expression');
-                })();
-}
-/** Generates a tuple of strings from the given TemplateLiteral. Returns an empty tuple if infinite. */
-export function TemplateLiteralGenerate(schema) {
-    const expression = TemplateLiteralParseExact(schema.pattern);
-    // prettier-ignore
-    return (IsTemplateLiteralExpressionFinite(expression)
-        ? [...TemplateLiteralExpressionGenerate(expression)]
-        : []);
-}

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

@@ -1,7 +0,0 @@
-export * from './finite.mjs';
-export * from './generate.mjs';
-export * from './syntax.mjs';
-export * from './parse.mjs';
-export * from './pattern.mjs';
-export * from './union.mjs';
-export * from './template-literal.mjs';

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

@@ -1,167 +0,0 @@
-import { TypeBoxError } from '../error/index.mjs';
-// ------------------------------------------------------------------
-// TemplateLiteralParserError
-// ------------------------------------------------------------------
-export class TemplateLiteralParserError extends TypeBoxError {
-}
-// -------------------------------------------------------------------
-// Unescape
-//
-// Unescape for these control characters specifically. Note that this
-// function is only called on non union group content, and where we
-// still want to allow the user to embed control characters in that
-// content. For review.
-// -------------------------------------------------------------------
-// prettier-ignore
-function Unescape(pattern) {
-    return pattern
-        .replace(/\\\$/g, '$')
-        .replace(/\\\*/g, '*')
-        .replace(/\\\^/g, '^')
-        .replace(/\\\|/g, '|')
-        .replace(/\\\(/g, '(')
-        .replace(/\\\)/g, ')');
-}
-// -------------------------------------------------------------------
-// Control Characters
-// -------------------------------------------------------------------
-function IsNonEscaped(pattern, index, char) {
-    return pattern[index] === char && pattern.charCodeAt(index - 1) !== 92;
-}
-function IsOpenParen(pattern, index) {
-    return IsNonEscaped(pattern, index, '(');
-}
-function IsCloseParen(pattern, index) {
-    return IsNonEscaped(pattern, index, ')');
-}
-function IsSeparator(pattern, index) {
-    return IsNonEscaped(pattern, index, '|');
-}
-// -------------------------------------------------------------------
-// Control Groups
-// -------------------------------------------------------------------
-function IsGroup(pattern) {
-    if (!(IsOpenParen(pattern, 0) && IsCloseParen(pattern, pattern.length - 1)))
-        return false;
-    let count = 0;
-    for (let index = 0; index < pattern.length; index++) {
-        if (IsOpenParen(pattern, index))
-            count += 1;
-        if (IsCloseParen(pattern, index))
-            count -= 1;
-        if (count === 0 && index !== pattern.length - 1)
-            return false;
-    }
-    return true;
-}
-// prettier-ignore
-function InGroup(pattern) {
-    return pattern.slice(1, pattern.length - 1);
-}
-// prettier-ignore
-function IsPrecedenceOr(pattern) {
-    let count = 0;
-    for (let index = 0; index < pattern.length; index++) {
-        if (IsOpenParen(pattern, index))
-            count += 1;
-        if (IsCloseParen(pattern, index))
-            count -= 1;
-        if (IsSeparator(pattern, index) && count === 0)
-            return true;
-    }
-    return false;
-}
-// prettier-ignore
-function IsPrecedenceAnd(pattern) {
-    for (let index = 0; index < pattern.length; index++) {
-        if (IsOpenParen(pattern, index))
-            return true;
-    }
-    return false;
-}
-// prettier-ignore
-function Or(pattern) {
-    let [count, start] = [0, 0];
-    const expressions = [];
-    for (let index = 0; index < pattern.length; index++) {
-        if (IsOpenParen(pattern, index))
-            count += 1;
-        if (IsCloseParen(pattern, index))
-            count -= 1;
-        if (IsSeparator(pattern, index) && count === 0) {
-            const range = pattern.slice(start, index);
-            if (range.length > 0)
-                expressions.push(TemplateLiteralParse(range));
-            start = index + 1;
-        }
-    }
-    const range = pattern.slice(start);
-    if (range.length > 0)
-        expressions.push(TemplateLiteralParse(range));
-    if (expressions.length === 0)
-        return { type: 'const', const: '' };
-    if (expressions.length === 1)
-        return expressions[0];
-    return { type: 'or', expr: expressions };
-}
-// prettier-ignore
-function And(pattern) {
-    function Group(value, index) {
-        if (!IsOpenParen(value, index))
-            throw new TemplateLiteralParserError(`TemplateLiteralParser: Index must point to open parens`);
-        let count = 0;
-        for (let scan = index; scan < value.length; scan++) {
-            if (IsOpenParen(value, scan))
-                count += 1;
-            if (IsCloseParen(value, scan))
-                count -= 1;
-            if (count === 0)
-                return [index, scan];
-        }
-        throw new TemplateLiteralParserError(`TemplateLiteralParser: Unclosed group parens in expression`);
-    }
-    function Range(pattern, index) {
-        for (let scan = index; scan < pattern.length; scan++) {
-            if (IsOpenParen(pattern, scan))
-                return [index, scan];
-        }
-        return [index, pattern.length];
-    }
-    const expressions = [];
-    for (let index = 0; index < pattern.length; index++) {
-        if (IsOpenParen(pattern, index)) {
-            const [start, end] = Group(pattern, index);
-            const range = pattern.slice(start, end + 1);
-            expressions.push(TemplateLiteralParse(range));
-            index = end;
-        }
-        else {
-            const [start, end] = Range(pattern, index);
-            const range = pattern.slice(start, end);
-            if (range.length > 0)
-                expressions.push(TemplateLiteralParse(range));
-            index = end - 1;
-        }
-    }
-    return ((expressions.length === 0) ? { type: 'const', const: '' } :
-        (expressions.length === 1) ? expressions[0] :
-            { type: 'and', expr: expressions });
-}
-// ------------------------------------------------------------------
-// TemplateLiteralParse
-// ------------------------------------------------------------------
-/** Parses a pattern and returns an expression tree */
-export function TemplateLiteralParse(pattern) {
-    // prettier-ignore
-    return (IsGroup(pattern) ? TemplateLiteralParse(InGroup(pattern)) :
-        IsPrecedenceOr(pattern) ? Or(pattern) :
-            IsPrecedenceAnd(pattern) ? And(pattern) :
-                { type: 'const', const: Unescape(pattern) });
-}
-// ------------------------------------------------------------------
-// TemplateLiteralParseExact
-// ------------------------------------------------------------------
-/** Parses a pattern and strips forward and trailing ^ and $ */
-export function TemplateLiteralParseExact(pattern) {
-    return TemplateLiteralParse(pattern.slice(1, pattern.length - 1));
-}

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

@@ -1,33 +0,0 @@
-import { PatternNumber, PatternString, PatternBoolean } from '../patterns/index.mjs';
-import { Kind } from '../symbols/index.mjs';
-import { TypeBoxError } from '../error/index.mjs';
-// ------------------------------------------------------------------
-// TypeGuard
-// ------------------------------------------------------------------
-import { IsTemplateLiteral, IsUnion, IsNumber, IsInteger, IsBigInt, IsString, IsLiteral, IsBoolean } from '../guard/kind.mjs';
-// ------------------------------------------------------------------
-// TemplateLiteralPatternError
-// ------------------------------------------------------------------
-export class TemplateLiteralPatternError extends TypeBoxError {
-}
-// ------------------------------------------------------------------
-// TemplateLiteralPattern
-// ------------------------------------------------------------------
-function Escape(value) {
-    return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
-}
-// prettier-ignore
-function Visit(schema, acc) {
-    return (IsTemplateLiteral(schema) ? schema.pattern.slice(1, schema.pattern.length - 1) :
-        IsUnion(schema) ? `(${schema.anyOf.map((schema) => Visit(schema, acc)).join('|')})` :
-            IsNumber(schema) ? `${acc}${PatternNumber}` :
-                IsInteger(schema) ? `${acc}${PatternNumber}` :
-                    IsBigInt(schema) ? `${acc}${PatternNumber}` :
-                        IsString(schema) ? `${acc}${PatternString}` :
-                            IsLiteral(schema) ? `${acc}${Escape(schema.const.toString())}` :
-                                IsBoolean(schema) ? `${acc}${PatternBoolean}` :
-                                    (() => { throw new TemplateLiteralPatternError(`Unexpected Kind '${schema[Kind]}'`); })());
-}
-export function TemplateLiteralPattern(kinds) {
-    return `^${kinds.map((schema) => Visit(schema, '')).join('')}\$`;
-}

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

@@ -1,55 +0,0 @@
-import { Literal } from '../literal/index.mjs';
-import { Boolean } from '../boolean/index.mjs';
-import { BigInt } from '../bigint/index.mjs';
-import { Number } from '../number/index.mjs';
-import { String } from '../string/index.mjs';
-import { UnionEvaluated } from '../union/index.mjs';
-import { Never } from '../never/index.mjs';
-// ------------------------------------------------------------------
-// SyntaxParsers
-// ------------------------------------------------------------------
-// prettier-ignore
-function* FromUnion(syntax) {
-    const trim = syntax.trim().replace(/"|'/g, '');
-    return (trim === 'boolean' ? yield Boolean() :
-        trim === 'number' ? yield Number() :
-            trim === 'bigint' ? yield BigInt() :
-                trim === 'string' ? yield String() :
-                    yield (() => {
-                        const literals = trim.split('|').map((literal) => Literal(literal.trim()));
-                        return (literals.length === 0 ? Never() :
-                            literals.length === 1 ? literals[0] :
-                                UnionEvaluated(literals));
-                    })());
-}
-// prettier-ignore
-function* FromTerminal(syntax) {
-    if (syntax[1] !== '{') {
-        const L = Literal('$');
-        const R = FromSyntax(syntax.slice(1));
-        return yield* [L, ...R];
-    }
-    for (let i = 2; i < syntax.length; i++) {
-        if (syntax[i] === '}') {
-            const L = FromUnion(syntax.slice(2, i));
-            const R = FromSyntax(syntax.slice(i + 1));
-            return yield* [...L, ...R];
-        }
-    }
-    yield Literal(syntax);
-}
-// prettier-ignore
-function* FromSyntax(syntax) {
-    for (let i = 0; i < syntax.length; i++) {
-        if (syntax[i] === '$') {
-            const L = Literal(syntax.slice(0, i));
-            const R = FromTerminal(syntax.slice(i));
-            return yield* [L, ...R];
-        }
-    }
-    yield Literal(syntax);
-}
-/** Parses TemplateLiteralSyntax and returns a tuple of TemplateLiteralKinds */
-export function TemplateLiteralSyntax(syntax) {
-    return [...FromSyntax(syntax)];
-}

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

@@ -1,13 +0,0 @@
-import { CreateType } from '../create/type.mjs';
-import { TemplateLiteralSyntax } from './syntax.mjs';
-import { TemplateLiteralPattern } from './pattern.mjs';
-import { IsString } from '../guard/value.mjs';
-import { Kind } from '../symbols/index.mjs';
-/** `[Json]` Creates a TemplateLiteral type */
-// prettier-ignore
-export function TemplateLiteral(unresolved, options) {
-    const pattern = IsString(unresolved)
-        ? TemplateLiteralPattern(TemplateLiteralSyntax(unresolved))
-        : TemplateLiteralPattern(unresolved);
-    return CreateType({ [Kind]: 'TemplateLiteral', type: 'string', pattern }, options);
-}

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

@@ -1,9 +0,0 @@
-import { UnionEvaluated } from '../union/index.mjs';
-import { Literal } from '../literal/index.mjs';
-import { TemplateLiteralGenerate } from './generate.mjs';
-/** Returns a Union from the given TemplateLiteral */
-export function TemplateLiteralToUnion(schema) {
-    const R = TemplateLiteralGenerate(schema);
-    const L = R.map((S) => Literal(S));
-    return UnionEvaluated(L);
-}

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

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

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

@@ -1,40 +0,0 @@
-import { TransformKind } from '../symbols/index.mjs';
-// ------------------------------------------------------------------
-// TypeGuard
-// ------------------------------------------------------------------
-import { IsTransform } from '../guard/kind.mjs';
-// ------------------------------------------------------------------
-// TransformBuilders
-// ------------------------------------------------------------------
-export class TransformDecodeBuilder {
-    constructor(schema) {
-        this.schema = schema;
-    }
-    Decode(decode) {
-        return new TransformEncodeBuilder(this.schema, decode);
-    }
-}
-// prettier-ignore
-export class TransformEncodeBuilder {
-    constructor(schema, decode) {
-        this.schema = schema;
-        this.decode = decode;
-    }
-    EncodeTransform(encode, schema) {
-        const Encode = (value) => schema[TransformKind].Encode(encode(value));
-        const Decode = (value) => this.decode(schema[TransformKind].Decode(value));
-        const Codec = { Encode: Encode, Decode: Decode };
-        return { ...schema, [TransformKind]: Codec };
-    }
-    EncodeSchema(encode, schema) {
-        const Codec = { Decode: this.decode, Encode: encode };
-        return { ...schema, [TransformKind]: Codec };
-    }
-    Encode(encode) {
-        return (IsTransform(this.schema) ? this.EncodeTransform(encode, this.schema) : this.EncodeSchema(encode, this.schema));
-    }
-}
-/** `[Json]` Creates a Transform type */
-export function Transform(schema) {
-    return new TransformDecodeBuilder(schema);
-}

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

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

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

@@ -1,9 +0,0 @@
-import { CreateType } from '../create/type.mjs';
-import { Kind } from '../symbols/index.mjs';
-/** `[Json]` Creates a Tuple type */
-export function Tuple(types, options) {
-    // prettier-ignore
-    return CreateType(types.length > 0 ?
-        { [Kind]: 'Tuple', type: 'array', items: types, additionalItems: false, minItems: types.length, maxItems: types.length } :
-        { [Kind]: 'Tuple', type: 'array', minItems: types.length, maxItems: types.length }, options);
-}

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

@@ -1,13 +0,0 @@
-// ------------------------------------------------------------------
-// JsonTypeBuilder
-// ------------------------------------------------------------------
-export { JsonTypeBuilder } from './json.mjs';
-// ------------------------------------------------------------------
-// JavaScriptTypeBuilder
-// ------------------------------------------------------------------
-import * as TypeBuilder from './type.mjs';
-import { JavaScriptTypeBuilder } from './javascript.mjs';
-/** JavaScript Type Builder with Static Resolution for TypeScript */
-const Type = TypeBuilder;
-export { JavaScriptTypeBuilder };
-export { Type };

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

@@ -1,89 +0,0 @@
-import { JsonTypeBuilder } from './json.mjs';
-import { AsyncIterator } from '../async-iterator/index.mjs';
-import { Awaited } from '../awaited/index.mjs';
-import { BigInt } from '../bigint/index.mjs';
-import { Constructor } from '../constructor/index.mjs';
-import { ConstructorParameters } from '../constructor-parameters/index.mjs';
-import { Date } from '../date/index.mjs';
-import { Function as FunctionType } from '../function/index.mjs';
-import { InstanceType } from '../instance-type/index.mjs';
-import { Iterator } from '../iterator/index.mjs';
-import { Parameters } from '../parameters/index.mjs';
-import { Promise } from '../promise/index.mjs';
-import { RegExp } from '../regexp/index.mjs';
-import { ReturnType } from '../return-type/index.mjs';
-import { Symbol } from '../symbol/index.mjs';
-import { Uint8Array } from '../uint8array/index.mjs';
-import { Undefined } from '../undefined/index.mjs';
-import { Void } from '../void/index.mjs';
-/** JavaScript Type Builder with Static Resolution for TypeScript */
-export class JavaScriptTypeBuilder extends JsonTypeBuilder {
-    /** `[JavaScript]` Creates a AsyncIterator type */
-    AsyncIterator(items, options) {
-        return AsyncIterator(items, options);
-    }
-    /** `[JavaScript]` Constructs a type by recursively unwrapping Promise types */
-    Awaited(schema, options) {
-        return Awaited(schema, options);
-    }
-    /** `[JavaScript]` Creates a BigInt type */
-    BigInt(options) {
-        return BigInt(options);
-    }
-    /** `[JavaScript]` Extracts the ConstructorParameters from the given Constructor type */
-    ConstructorParameters(schema, options) {
-        return ConstructorParameters(schema, options);
-    }
-    /** `[JavaScript]` Creates a Constructor type */
-    Constructor(parameters, instanceType, options) {
-        return Constructor(parameters, instanceType, options);
-    }
-    /** `[JavaScript]` Creates a Date type */
-    Date(options = {}) {
-        return Date(options);
-    }
-    /** `[JavaScript]` Creates a Function type */
-    Function(parameters, returnType, options) {
-        return FunctionType(parameters, returnType, options);
-    }
-    /** `[JavaScript]` Extracts the InstanceType from the given Constructor type */
-    InstanceType(schema, options) {
-        return InstanceType(schema, options);
-    }
-    /** `[JavaScript]` Creates an Iterator type */
-    Iterator(items, options) {
-        return Iterator(items, options);
-    }
-    /** `[JavaScript]` Extracts the Parameters from the given Function type */
-    Parameters(schema, options) {
-        return Parameters(schema, options);
-    }
-    /** `[JavaScript]` Creates a Promise type */
-    Promise(item, options) {
-        return Promise(item, options);
-    }
-    /** `[JavaScript]` Creates a RegExp type */
-    RegExp(unresolved, options) {
-        return RegExp(unresolved, options);
-    }
-    /** `[JavaScript]` Extracts the ReturnType from the given Function type */
-    ReturnType(type, options) {
-        return ReturnType(type, options);
-    }
-    /** `[JavaScript]` Creates a Symbol type */
-    Symbol(options) {
-        return Symbol(options);
-    }
-    /** `[JavaScript]` Creates a Undefined type */
-    Undefined(options) {
-        return Undefined(options);
-    }
-    /** `[JavaScript]` Creates a Uint8Array type */
-    Uint8Array(options) {
-        return Uint8Array(options);
-    }
-    /** `[JavaScript]` Creates a Void type */
-    Void(options) {
-        return Void(options);
-    }
-}