@wener/utils 1.1.33 → 1.1.35

package/lib/schema/typebox/gen/codegen/expression/expression.js

@@ -0,0 +1,381 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox-expression
+
+The MIT License (MIT)
+
+Copyright (c) 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.
+
+---------------------------------------------------------------------------*/ // -------------------------------------------------------------------------
+// Expression: Error
+// -------------------------------------------------------------------------
+export var Expression;
+(function(Expression) {
+    function And(expressions, options = {}) {
+        const expr = globalThis.Array.isArray(expressions) ? expressions : [
+            ...expressions()
+        ];
+        if (expr.length === 0) return Expression.False();
+        if (expr.length === 1) return expr[0];
+        return {
+            ...options,
+            type: 'And',
+            expr
+        };
+    }
+    /** Creates a `And` expression where each sub expression is evaluated in sequence */ Expression.And = And;
+    function Call(target, parameters, expression, options = {}) {
+        return {
+            ...options,
+            type: 'Call',
+            target,
+            parameters,
+            expr: expression
+        };
+    }
+    /** Creates a `Call` expression that will invoke the object target and check the return for the given sub expression */ Expression.Call = Call;
+    function Equals(value, options = {}) {
+        return {
+            ...options,
+            type: 'Equals',
+            value
+        };
+    }
+    /** Creates a `Equals` expression that will compare for value equality */ Expression.Equals = Equals;
+    function Function(callback, options = {}) {
+        return {
+            ...options,
+            type: 'Function',
+            callback
+        };
+    }
+    /** Creates a `Function` expression which invokes the given callback to check a value */ Expression.Function = Function;
+    function ElementsDistinct(options = {}) {
+        return {
+            ...options,
+            type: 'ElementsDistinct'
+        };
+    }
+    /** Creates a `ElementsDistinct` expression which will check an arrays elements are structurally distinct  */ Expression.ElementsDistinct = ElementsDistinct;
+    function Elements(expression, options = {}) {
+        return {
+            ...options,
+            type: 'Elements',
+            expr: expression
+        };
+    }
+    /** Creates a `Elements` expression that will check an arrays elements for the given sub expression */ Expression.Elements = Elements;
+    function False(options = {}) {
+        return {
+            ...options,
+            type: 'False'
+        };
+    }
+    /** Creates a `False` expression that evaluates `false` */ Expression.False = False;
+    function GreaterThanEqual(value, options = {}) {
+        return {
+            ...options,
+            type: 'GreaterThanEqual',
+            value
+        };
+    }
+    /** Creates a `GreaterThanEqual` comparison expression */ Expression.GreaterThanEqual = GreaterThanEqual;
+    function GreaterThan(value, options = {}) {
+        return {
+            ...options,
+            type: 'GreaterThan',
+            value
+        };
+    }
+    /** Creates a `GreaterThan` comparison expression */ Expression.GreaterThan = GreaterThan;
+    function IfThenElse($if, $then, $else, options = {}) {
+        return {
+            ...options,
+            type: 'IfThenElse',
+            if: $if,
+            then: $then,
+            else: $else
+        };
+    }
+    /** Creates a `IfThenElse` expression that will evaluate the `$if` expression followed by either the `$then` of `$else` expressions */ Expression.IfThenElse = IfThenElse;
+    function Index(index, expression, options = {}) {
+        return {
+            ...options,
+            type: 'Index',
+            index,
+            expr: expression
+        };
+    }
+    /** Creates a `Index` expression that will evaluate an array element by the given sub expression */ Expression.Index = Index;
+    function InstanceOf(value, options = {}) {
+        return {
+            ...options,
+            type: 'InstanceOf',
+            value
+        };
+    }
+    /** Creates a `InstanceOf` expression that will apply the `instanceof` operator */ Expression.InstanceOf = InstanceOf;
+    function IsArray(options = {}) {
+        return {
+            ...options,
+            type: 'IsArray'
+        };
+    }
+    /** Creates a `IsArray` expression that will check a value as an array */ Expression.IsArray = IsArray;
+    function IsNaN(options = {}) {
+        return {
+            ...options,
+            type: 'IsNaN'
+        };
+    }
+    /** Creates a `IsNaN` expression that will check for NaN */ Expression.IsNaN = IsNaN;
+    function IsInteger(options = {}) {
+        return {
+            ...options,
+            type: 'IsInteger'
+        };
+    }
+    /** Creates a `IsInteger` expression that will check for numeric integer values */ Expression.IsInteger = IsInteger;
+    function IsObject(options = {}) {
+        return Expression.TypeOf('object', options);
+    }
+    /** Creates a `IsObject` expression that will check a value as an object */ Expression.IsObject = IsObject;
+    function IsBigInt(options = {}) {
+        return Expression.TypeOf('bigint', options);
+    }
+    /** Creates a `IsBigInt` expression that will check a value as a bigint */ Expression.IsBigInt = IsBigInt;
+    function IsBoolean(options = {}) {
+        return Expression.TypeOf('boolean', options);
+    }
+    /** Creates a `IsBoolean` expression that will check a value as a boolean */ Expression.IsBoolean = IsBoolean;
+    function IsFinite(options = {}) {
+        return {
+            ...options,
+            type: 'IsFinite'
+        };
+    }
+    /** Creates a `IsFinite` expression that will check a numeric value if finite */ Expression.IsFinite = IsFinite;
+    function IsFunction(options = {}) {
+        return Expression.TypeOf('function', options);
+    }
+    /** Creates a `IsFunction` expression that will check a value as a function */ Expression.IsFunction = IsFunction;
+    function IsNumber(options = {}) {
+        return Expression.TypeOf('number', options);
+    }
+    /** Creates a `IsNumber` expression that will check a value as a number */ Expression.IsNumber = IsNumber;
+    function IsSafeInteger(options = {}) {
+        return {
+            ...options,
+            type: 'IsSafeInteger'
+        };
+    }
+    /** Creates a `IsSafeInteger` expression that will check a numeric value if finite */ Expression.IsSafeInteger = IsSafeInteger;
+    function IsString(options = {}) {
+        return Expression.TypeOf('string', options);
+    }
+    /** Creates a `IsString` expression that will check a value as a string */ Expression.IsString = IsString;
+    function IsSymbol(options = {}) {
+        return Expression.TypeOf('symbol', options);
+    }
+    /** Creates a `IsSymbol` expression that will check a value as a symbol */ Expression.IsSymbol = IsSymbol;
+    function IsUndefined(options = {}) {
+        return {
+            ...options,
+            type: 'IsUndefined'
+        };
+    }
+    /** Creates a `IsUndefined` expression that will check a value is undefined */ Expression.IsUndefined = IsUndefined;
+    function IsNull(options = {}) {
+        return Expression.Equals(null, options);
+    }
+    /** Creates a `IsNull` expression that will check a value is null */ Expression.IsNull = IsNull;
+    function IsPattern(pattern, options = {}) {
+        return {
+            ...options,
+            type: 'IsPattern',
+            pattern
+        };
+    }
+    /** Creates a `IsPattern` expression that will check a string with a regular expression */ Expression.IsPattern = IsPattern;
+    function KeyIn(value, options = {}) {
+        return {
+            ...options,
+            type: 'KeyIn',
+            value
+        };
+    }
+    /** Creates a KeyIn expression that will check if a key exists on this value */ Expression.KeyIn = KeyIn;
+    function LessThanEqual(value, options = {}) {
+        return {
+            ...options,
+            type: 'LessThanEqual',
+            value
+        };
+    }
+    /** Creates a `LessThanEqual` comparison expression */ Expression.LessThanEqual = LessThanEqual;
+    function LessThan(value, options = {}) {
+        return {
+            ...options,
+            type: 'LessThan',
+            value
+        };
+    }
+    /** Creates a `LessThan` comparison expression */ Expression.LessThan = LessThan;
+    function MultipleOf(value, options = {}) {
+        return {
+            ...options,
+            type: 'MultipleOf',
+            value
+        };
+    }
+    /** Creates a `MultipleOf` modulus expression that is true if the result is zero */ Expression.MultipleOf = MultipleOf;
+    function Not(expression, options = {}) {
+        return {
+            ...options,
+            type: 'Not',
+            expr: expression
+        };
+    }
+    /** Creates a `Not` expression where the result of the sub expression is inverted */ Expression.Not = Not;
+    function Or(expressions, options = {}) {
+        const expr = globalThis.Array.isArray(expressions) ? expressions : [
+            ...expressions()
+        ];
+        if (expr.length === 0) return Expression.False();
+        if (expr.length === 1) return expr[0];
+        return {
+            ...options,
+            type: 'Or',
+            expr
+        };
+    }
+    /** Creates a `Or` expression where each sub expression is evaluated in sequence */ Expression.Or = Or;
+    function PropertiesExcludePattern(pattern, expression, options = {}) {
+        return {
+            ...options,
+            type: 'PropertiesExcludePattern',
+            expr: expression,
+            pattern
+        };
+    }
+    /** Creates a `PropertiesExcludePattern` expression that will enumerate each key matching the given regular expression */ Expression.PropertiesExcludePattern = PropertiesExcludePattern;
+    function PropertiesExclude(keys, expression, options = {}) {
+        return {
+            ...options,
+            type: 'PropertiesExclude',
+            expr: expression,
+            keys
+        };
+    }
+    /** Creates a `PropertiesExclude` expression that will enumerate the unselected keys and check each for the sub expression */ Expression.PropertiesExclude = PropertiesExclude;
+    function PropertiesIncludePattern(pattern, expression, options = {}) {
+        return {
+            ...options,
+            type: 'PropertiesIncludePattern',
+            expr: expression,
+            pattern
+        };
+    }
+    /** Creates a `PropertiesIncludePattern` expression that will enumerate each key matching the given regular expression */ Expression.PropertiesIncludePattern = PropertiesIncludePattern;
+    function PropertiesInclude(keys, expression, options = {}) {
+        return {
+            ...options,
+            type: 'PropertiesInclude',
+            expr: expression,
+            keys
+        };
+    }
+    /** Creates a `PropertiesInclude` expression that will enumerate the selected keys and check each for the sub expression */ Expression.PropertiesInclude = PropertiesInclude;
+    function PropertiesLength(value, options = {}) {
+        return {
+            ...options,
+            type: 'PropertiesLength',
+            value
+        };
+    }
+    /** Creates a `PropertiesLength` expression that checks an object a property length that equals the given value */ Expression.PropertiesLength = PropertiesLength;
+    function PropertiesMaximum(value, options = {}) {
+        return {
+            ...options,
+            type: 'PropertiesMaximum',
+            value
+        };
+    }
+    /** Creates a `PropertiesMaximum` expression that will check an object has a property length less or equal the given value */ Expression.PropertiesMaximum = PropertiesMaximum;
+    function PropertiesMinimum(value, options = {}) {
+        return {
+            ...options,
+            type: 'PropertiesMinimum',
+            value
+        };
+    }
+    /** Creates a `PropertiesMinimum` expression that will check an object has a property length greater or equal the given value */ Expression.PropertiesMinimum = PropertiesMinimum;
+    function Properties(expression, options = {}) {
+        return {
+            ...options,
+            type: 'Properties',
+            expr: expression
+        };
+    }
+    /** Creates a `Properties` expression that will enumerate all object properties and check for the given sub expression */ Expression.Properties = Properties;
+    function PropertyKeys(keys, options = {}) {
+        return {
+            ...options,
+            type: 'PropertyKeys',
+            keys
+        };
+    }
+    /** Creates a `PropertyKeys` expression that will check an object has the specified keys */ Expression.PropertyKeys = PropertyKeys;
+    function Property(key, expression, options = {}) {
+        return {
+            ...options,
+            type: 'Property',
+            key,
+            expr: expression
+        };
+    }
+    /** Creates a `Property` expression that will evaluate the property value by the given sub expression */ Expression.Property = Property;
+    function Ref(value, options = {}) {
+        return {
+            ...options,
+            type: 'Ref',
+            $ref: value
+        };
+    }
+    /** Creates a `Ref` that will reference another part of the expression tree via $id */ Expression.Ref = Ref;
+    function True(options = {}) {
+        return {
+            ...options,
+            type: 'True'
+        };
+    }
+    /** Creates a `True` expression that evaluates `true` */ Expression.True = True;
+    function TypeOf(value, options = {}) {
+        return {
+            ...options,
+            type: 'TypeOf',
+            value
+        };
+    }
+    /** Creates a `TypeOf` expression that will apply `typeof` operator for the evaluated value */ Expression.TypeOf = TypeOf;
+})(Expression || (Expression = {}));
+
+//# sourceMappingURL=expression.js.map

package/lib/schema/typebox/gen/codegen/expression/expression.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/schema/typebox/gen/codegen/expression/expression.ts"],"sourcesContent":["/*--------------------------------------------------------------------------\n\n@sinclair/typebox-expression\n\nThe MIT License (MIT)\n\nCopyright (c) 2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n\n---------------------------------------------------------------------------*/\n\n// -------------------------------------------------------------------------\n// Expression: Error\n// -------------------------------------------------------------------------\nexport interface ExpressionError {\n  expression: Expression;\n  path: string;\n  value: unknown;\n}\n\n// -------------------------------------------------------------------------\n// Expression: Tree\n// -------------------------------------------------------------------------\n\nexport type Equatable = string | number | boolean | null | undefined;\nexport type Compariable = number | bigint;\nexport type TypeOf = 'undefined' | 'symbol' | 'function' | 'string' | 'number' | 'boolean' | 'bigint' | 'object';\n\nexport interface ExpressionOptions {\n  $id?: string;\n  [key: string]: any;\n}\nexport interface AndExpression extends ExpressionOptions {\n  type: 'And';\n  expr: Expression[];\n}\nexport interface CallExpression<\n  E extends Expression = Expression,\n  T extends string = string,\n  A extends unknown[] = unknown[],\n> extends ExpressionOptions {\n  type: 'Call';\n  target: T;\n  parameters: [...A];\n  expr: E;\n}\n\nexport interface ElementsDistinctExpression extends ExpressionOptions {\n  type: 'ElementsDistinct';\n}\nexport interface ElementsExpression<E extends Expression = Expression> extends ExpressionOptions {\n  type: 'Elements';\n  expr: E;\n}\nexport interface EqualsExpression<T extends Equatable = Equatable> extends ExpressionOptions {\n  type: 'Equals';\n  value: T;\n}\nexport type FunctionExpressionCallback = (value: unknown) => boolean;\n\nexport interface FunctionExpression<F extends FunctionExpressionCallback = FunctionExpressionCallback>\n  extends ExpressionOptions {\n  type: 'Function';\n  callback: F;\n}\nexport interface GreaterThanEqualExpression<T extends Compariable = Compariable> extends ExpressionOptions {\n  type: 'GreaterThanEqual';\n  value: T;\n}\nexport interface GreaterThanExpression<T extends Compariable = Compariable> extends ExpressionOptions {\n  type: 'GreaterThan';\n  value: T;\n}\nexport interface FalseExpression extends ExpressionOptions {\n  type: 'False';\n}\nexport interface IfThenElseExpression extends ExpressionOptions {\n  type: 'IfThenElse';\n  if: Expression;\n  then: Expression;\n  else: Expression;\n}\nexport interface InstanceOfExpression<T extends string = string> extends ExpressionOptions {\n  type: 'InstanceOf';\n  value: T;\n}\nexport interface IndexExpression<E extends Expression = Expression, I extends number = number>\n  extends ExpressionOptions {\n  type: 'Index';\n  index: I;\n  expr: E;\n}\n\nexport interface IsArrayExpression extends ExpressionOptions {\n  type: 'IsArray';\n}\nexport interface IsBigIntExpression extends TypeOfExpression<'bigint'> {}\nexport interface IsBooleanExpression extends TypeOfExpression<'boolean'> {}\nexport interface IsFiniteExpression extends ExpressionOptions {\n  type: 'IsFinite';\n}\nexport interface IsFunctionExpression extends TypeOfExpression<'function'> {}\nexport interface IsIntegerExpression extends ExpressionOptions {\n  type: 'IsInteger';\n}\nexport interface IsNaNExpression extends ExpressionOptions {\n  type: 'IsNaN';\n}\nexport interface IsNullExpression extends EqualsExpression<null> {}\nexport interface IsNumberExpression extends TypeOfExpression<'number'> {}\nexport interface IsSafeIntegerExpression extends ExpressionOptions {\n  type: 'IsSafeInteger';\n}\nexport interface IsObjectExpression extends TypeOfExpression<'object'> {}\nexport interface IsStringExpression extends TypeOfExpression<'string'> {}\nexport interface IsSymbolExpression extends TypeOfExpression<'symbol'> {}\nexport interface IsUndefinedExpression extends ExpressionOptions {\n  type: 'IsUndefined';\n}\nexport interface KeyInExpression<T extends string = string> extends ExpressionOptions {\n  type: 'KeyIn';\n  value: T;\n}\nexport interface OrExpression extends ExpressionOptions {\n  type: 'Or';\n  expr: Expression[];\n}\nexport interface NotExpression<E extends Expression = Expression> extends ExpressionOptions {\n  type: 'Not';\n  expr: E;\n}\nexport interface LessThanEqualExpression<T extends Compariable = Compariable> extends ExpressionOptions {\n  type: 'LessThanEqual';\n  value: T;\n}\nexport interface LessThanExpression<T extends Compariable = Compariable> extends ExpressionOptions {\n  type: 'LessThan';\n  value: T;\n}\nexport interface MultipleOfExpression<T extends number = number> extends ExpressionOptions {\n  type: 'MultipleOf';\n  value: T;\n}\nexport interface PropertiesIncludePatternExpression<E extends Expression = Expression> extends ExpressionOptions {\n  type: 'PropertiesIncludePattern';\n  pattern: string;\n  expr: E;\n}\nexport interface PropertiesIncludeExpression<E extends Expression = Expression, K extends string[] = string[]>\n  extends ExpressionOptions {\n  type: 'PropertiesInclude';\n  keys: K;\n  expr: E;\n}\nexport interface PropertiesExcludePatternExpression<E extends Expression = Expression> extends ExpressionOptions {\n  type: 'PropertiesExcludePattern';\n  pattern: string;\n  expr: E;\n}\nexport interface PropertiesExcludeExpression<E extends Expression = Expression, K extends string[] = string[]>\n  extends ExpressionOptions {\n  type: 'PropertiesExclude';\n  keys: K;\n  expr: E;\n}\nexport interface PropertiesLengthExpression<T extends number = number> extends ExpressionOptions {\n  type: 'PropertiesLength';\n  value: T;\n}\nexport interface PropertiesMaximumExpression<T extends number = number> extends ExpressionOptions {\n  type: 'PropertiesMaximum';\n  value: T;\n}\nexport interface PropertiesMinimumExpression<T extends number = number> extends ExpressionOptions {\n  type: 'PropertiesMinimum';\n  value: T;\n}\nexport interface PropertiesExpression<E extends Expression = Expression> extends ExpressionOptions {\n  type: 'Properties';\n  expr: E;\n}\nexport interface PropertyKeysExpression<T extends readonly string[] = string[]> extends ExpressionOptions {\n  type: 'PropertyKeys';\n  keys: [...T];\n}\nexport interface PropertyExpression<E extends Expression = Expression, K extends string = string>\n  extends ExpressionOptions {\n  type: 'Property';\n  key: K;\n  expr: E;\n}\nexport interface RefExpression<T extends string = string> extends ExpressionOptions {\n  type: 'Ref';\n  $ref: T;\n}\nexport interface IsPatternExpression extends ExpressionOptions {\n  type: 'IsPattern';\n  pattern: string;\n}\nexport interface TrueExpression extends ExpressionOptions {\n  type: 'True';\n}\nexport interface TypeOfExpression<T extends TypeOf = TypeOf> extends ExpressionOptions {\n  type: 'TypeOf';\n  value: T;\n}\nexport type Expression =\n  | AndExpression\n  | CallExpression\n  | FalseExpression\n  | FunctionExpression\n  | ElementsDistinctExpression\n  | ElementsExpression\n  | EqualsExpression\n  | GreaterThanExpression\n  | GreaterThanEqualExpression\n  | IfThenElseExpression\n  | IndexExpression\n  | InstanceOfExpression\n  | IsArrayExpression\n  | IsIntegerExpression\n  | IsNaNExpression\n  | IsObjectExpression\n  | IsBigIntExpression\n  | IsBooleanExpression\n  | IsFiniteExpression\n  | IsFunctionExpression\n  | IsNullExpression\n  | IsNumberExpression\n  | IsSafeIntegerExpression\n  | IsStringExpression\n  | IsSymbolExpression\n  | IsUndefinedExpression\n  | KeyInExpression\n  | LessThanEqualExpression\n  | LessThanExpression\n  | MultipleOfExpression\n  | NotExpression\n  | OrExpression\n  | PropertiesIncludeExpression\n  | PropertiesIncludePatternExpression\n  | PropertiesExcludeExpression\n  | PropertiesExcludePatternExpression\n  | PropertiesLengthExpression\n  | PropertiesMaximumExpression\n  | PropertiesMinimumExpression\n  | PropertiesExpression\n  | PropertyKeysExpression\n  | PropertyExpression\n  | RefExpression\n  | IsPatternExpression\n  | TrueExpression\n  | TypeOfExpression;\n\n// ---------------------------------------------------------------\n// Expression: Builder\n// ---------------------------------------------------------------\n\n/** Type Expressions builder used to assert JavaScript values */\nexport namespace Expression {\n  /** Creates a `And` expression where each sub expression is evaluated in sequence */\n  export function And<E extends Expression>(\n    expressions: (() => Generator<E>) | Array<E>,\n    options: ExpressionOptions = {},\n  ): Expression {\n    const expr = globalThis.Array.isArray(expressions) ? expressions : [...expressions()];\n    if (expr.length === 0) return Expression.False();\n    if (expr.length === 1) return expr[0];\n    return { ...options, type: 'And', expr };\n  }\n  /** Creates a `Call` expression that will invoke the object target and check the return for the given sub expression */\n  export function Call<E extends Expression, T extends string, P extends unknown[]>(\n    target: T,\n    parameters: P,\n    expression: E,\n    options: ExpressionOptions = {},\n  ): CallExpression<E, T, P> {\n    return { ...options, type: 'Call', target, parameters, expr: expression };\n  }\n  /** Creates a `Equals` expression that will compare for value equality */\n  export function Equals<T extends Equatable>(value: T, options: ExpressionOptions = {}): EqualsExpression<T> {\n    return { ...options, type: 'Equals', value };\n  }\n  /** Creates a `Function` expression which invokes the given callback to check a value */\n  export function Function<F extends (value: unknown) => boolean>(\n    callback: F,\n    options: ExpressionOptions = {},\n  ): FunctionExpression<F> {\n    return { ...options, type: 'Function', callback };\n  }\n  /** Creates a `ElementsDistinct` expression which will check an arrays elements are structurally distinct  */\n  export function ElementsDistinct(options: ExpressionOptions = {}): ElementsDistinctExpression {\n    return { ...options, type: 'ElementsDistinct' };\n  }\n  /** Creates a `Elements` expression that will check an arrays elements for the given sub expression */\n  export function Elements<E extends Expression>(\n    expression: E,\n    options: ExpressionOptions = {},\n  ): ElementsExpression<E> {\n    return { ...options, type: 'Elements', expr: expression };\n  }\n  /** Creates a `False` expression that evaluates `false` */\n  export function False(options: ExpressionOptions = {}): FalseExpression {\n    return { ...options, type: 'False' };\n  }\n  /** Creates a `GreaterThanEqual` comparison expression */\n  export function GreaterThanEqual<T extends Compariable>(\n    value: T,\n    options: ExpressionOptions = {},\n  ): GreaterThanEqualExpression<T> {\n    return { ...options, type: 'GreaterThanEqual', value };\n  }\n  /** Creates a `GreaterThan` comparison expression */\n  export function GreaterThan<T extends Compariable>(\n    value: T,\n    options: ExpressionOptions = {},\n  ): GreaterThanExpression<T> {\n    return { ...options, type: 'GreaterThan', value };\n  }\n  /** Creates a `IfThenElse` expression that will evaluate the `$if` expression followed by either the `$then` of `$else` expressions */\n  export function IfThenElse(\n    $if: Expression,\n    $then: Expression,\n    $else: Expression,\n    options: ExpressionOptions = {},\n  ): IfThenElseExpression {\n    return { ...options, type: 'IfThenElse', if: $if, then: $then, else: $else };\n  }\n  /** Creates a `Index` expression that will evaluate an array element by the given sub expression */\n  export function Index<E extends Expression, I extends number>(\n    index: I,\n    expression: E,\n    options: ExpressionOptions = {},\n  ): IndexExpression<E, I> {\n    return { ...options, type: 'Index', index, expr: expression };\n  }\n  /** Creates a `InstanceOf` expression that will apply the `instanceof` operator */\n  export function InstanceOf<T extends string>(value: T, options: ExpressionOptions = {}): InstanceOfExpression<T> {\n    return { ...options, type: 'InstanceOf', value };\n  }\n  /** Creates a `IsArray` expression that will check a value as an array */\n  export function IsArray(options: ExpressionOptions = {}): IsArrayExpression {\n    return { ...options, type: 'IsArray' };\n  }\n  /** Creates a `IsNaN` expression that will check for NaN */\n  export function IsNaN(options: ExpressionOptions = {}): IsNaNExpression {\n    return { ...options, type: 'IsNaN' };\n  }\n  /** Creates a `IsInteger` expression that will check for numeric integer values */\n  export function IsInteger(options: ExpressionOptions = {}): IsIntegerExpression {\n    return { ...options, type: 'IsInteger' };\n  }\n  /** Creates a `IsObject` expression that will check a value as an object */\n  export function IsObject(options: ExpressionOptions = {}): IsObjectExpression {\n    return Expression.TypeOf('object', options);\n  }\n  /** Creates a `IsBigInt` expression that will check a value as a bigint */\n  export function IsBigInt(options: ExpressionOptions = {}): IsBigIntExpression {\n    return Expression.TypeOf('bigint', options);\n  }\n  /** Creates a `IsBoolean` expression that will check a value as a boolean */\n  export function IsBoolean(options: ExpressionOptions = {}): IsBooleanExpression {\n    return Expression.TypeOf('boolean', options);\n  }\n  /** Creates a `IsFinite` expression that will check a numeric value if finite */\n  export function IsFinite(options: ExpressionOptions = {}): IsFiniteExpression {\n    return { ...options, type: 'IsFinite' };\n  }\n  /** Creates a `IsFunction` expression that will check a value as a function */\n  export function IsFunction(options: ExpressionOptions = {}): IsFunctionExpression {\n    return Expression.TypeOf('function', options);\n  }\n  /** Creates a `IsNumber` expression that will check a value as a number */\n  export function IsNumber(options: ExpressionOptions = {}): IsNumberExpression {\n    return Expression.TypeOf('number', options);\n  }\n  /** Creates a `IsSafeInteger` expression that will check a numeric value if finite */\n  export function IsSafeInteger(options: ExpressionOptions = {}): IsSafeIntegerExpression {\n    return { ...options, type: 'IsSafeInteger' };\n  }\n  /** Creates a `IsString` expression that will check a value as a string */\n  export function IsString(options: ExpressionOptions = {}): IsStringExpression {\n    return Expression.TypeOf('string', options);\n  }\n  /** Creates a `IsSymbol` expression that will check a value as a symbol */\n  export function IsSymbol(options: ExpressionOptions = {}): IsSymbolExpression {\n    return Expression.TypeOf('symbol', options);\n  }\n  /** Creates a `IsUndefined` expression that will check a value is undefined */\n  export function IsUndefined(options: ExpressionOptions = {}): IsUndefinedExpression {\n    return { ...options, type: 'IsUndefined' };\n  }\n  /** Creates a `IsNull` expression that will check a value is null */\n  export function IsNull(options: ExpressionOptions = {}): IsNullExpression {\n    return Expression.Equals(null, options);\n  }\n  /** Creates a `IsPattern` expression that will check a string with a regular expression */\n  export function IsPattern(pattern: string, options: ExpressionOptions = {}): IsPatternExpression {\n    return { ...options, type: 'IsPattern', pattern };\n  }\n  /** Creates a KeyIn expression that will check if a key exists on this value */\n  export function KeyIn<T extends string>(value: T, options: ExpressionOptions = {}): KeyInExpression<T> {\n    return { ...options, type: 'KeyIn', value };\n  }\n  /** Creates a `LessThanEqual` comparison expression */\n  export function LessThanEqual<T extends Compariable>(\n    value: T,\n    options: ExpressionOptions = {},\n  ): LessThanEqualExpression<T> {\n    return { ...options, type: 'LessThanEqual', value };\n  }\n  /** Creates a `LessThan` comparison expression */\n  export function LessThan<T extends Compariable>(value: T, options: ExpressionOptions = {}): LessThanExpression<T> {\n    return { ...options, type: 'LessThan', value };\n  }\n  /** Creates a `MultipleOf` modulus expression that is true if the result is zero */\n  export function MultipleOf<T extends number>(value: T, options: ExpressionOptions = {}): MultipleOfExpression<T> {\n    return { ...options, type: 'MultipleOf', value };\n  }\n  /** Creates a `Not` expression where the result of the sub expression is inverted */\n  export function Not<E extends Expression>(expression: E, options: ExpressionOptions = {}): NotExpression<E> {\n    return { ...options, type: 'Not', expr: expression };\n  }\n  /** Creates a `Or` expression where each sub expression is evaluated in sequence */\n  export function Or<E extends Expression>(\n    expressions: (() => Generator<E>) | Array<E>,\n    options: ExpressionOptions = {},\n  ): Expression {\n    const expr = globalThis.Array.isArray(expressions) ? expressions : [...expressions()];\n    if (expr.length === 0) return Expression.False();\n    if (expr.length === 1) return expr[0];\n    return { ...options, type: 'Or', expr };\n  }\n  /** Creates a `PropertiesExcludePattern` expression that will enumerate each key matching the given regular expression */\n  export function PropertiesExcludePattern<E extends Expression>(\n    pattern: string,\n    expression: E,\n    options: ExpressionOptions = {},\n  ): PropertiesExcludePatternExpression<E> {\n    return { ...options, type: 'PropertiesExcludePattern', expr: expression, pattern };\n  }\n  /** Creates a `PropertiesExclude` expression that will enumerate the unselected keys and check each for the sub expression */\n  export function PropertiesExclude<E extends Expression, K extends string[]>(\n    keys: K,\n    expression: E,\n    options: ExpressionOptions = {},\n  ): PropertiesExcludeExpression<E, K> {\n    return { ...options, type: 'PropertiesExclude', expr: expression, keys };\n  }\n  /** Creates a `PropertiesIncludePattern` expression that will enumerate each key matching the given regular expression */\n  export function PropertiesIncludePattern<E extends Expression>(\n    pattern: string,\n    expression: E,\n    options: ExpressionOptions = {},\n  ): PropertiesIncludePatternExpression<E> {\n    return { ...options, type: 'PropertiesIncludePattern', expr: expression, pattern };\n  }\n  /** Creates a `PropertiesInclude` expression that will enumerate the selected keys and check each for the sub expression */\n  export function PropertiesInclude<E extends Expression, K extends string[]>(\n    keys: K,\n    expression: E,\n    options: ExpressionOptions = {},\n  ): PropertiesIncludeExpression<E, K> {\n    return { ...options, type: 'PropertiesInclude', expr: expression, keys };\n  }\n  /** Creates a `PropertiesLength` expression that checks an object a property length that equals the given value */\n  export function PropertiesLength<T extends number>(\n    value: T,\n    options: ExpressionOptions = {},\n  ): PropertiesLengthExpression<T> {\n    return { ...options, type: 'PropertiesLength', value };\n  }\n  /** Creates a `PropertiesMaximum` expression that will check an object has a property length less or equal the given value */\n  export function PropertiesMaximum<T extends number>(\n    value: T,\n    options: ExpressionOptions = {},\n  ): PropertiesMaximumExpression<T> {\n    return { ...options, type: 'PropertiesMaximum', value };\n  }\n  /** Creates a `PropertiesMinimum` expression that will check an object has a property length greater or equal the given value */\n  export function PropertiesMinimum<T extends number>(\n    value: T,\n    options: ExpressionOptions = {},\n  ): PropertiesMinimumExpression<T> {\n    return { ...options, type: 'PropertiesMinimum', value };\n  }\n  /** Creates a `Properties` expression that will enumerate all object properties and check for the given sub expression */\n  export function Properties<E extends Expression>(\n    expression: E,\n    options: ExpressionOptions = {},\n  ): PropertiesExpression<E> {\n    return { ...options, type: 'Properties', expr: expression };\n  }\n  /** Creates a `PropertyKeys` expression that will check an object has the specified keys */\n  export function PropertyKeys<T extends string[]>(\n    keys: T,\n    options: ExpressionOptions = {},\n  ): PropertyKeysExpression<T> {\n    return { ...options, type: 'PropertyKeys', keys };\n  }\n  /** Creates a `Property` expression that will evaluate the property value by the given sub expression */\n  export function Property<E extends Expression, K extends string>(\n    key: K,\n    expression: E,\n    options: ExpressionOptions = {},\n  ): PropertyExpression<E, K> {\n    return { ...options, type: 'Property', key, expr: expression };\n  }\n  /** Creates a `Ref` that will reference another part of the expression tree via $id */\n  export function Ref<T extends string>(value: T, options: ExpressionOptions = {}): RefExpression<T> {\n    return { ...options, type: 'Ref', $ref: value };\n  }\n  /** Creates a `True` expression that evaluates `true` */\n  export function True(options: ExpressionOptions = {}): TrueExpression {\n    return { ...options, type: 'True' };\n  }\n  /** Creates a `TypeOf` expression that will apply `typeof` operator for the evaluated value */\n  export function TypeOf<E extends TypeOf>(value: E, options: ExpressionOptions = {}): TypeOfExpression<E> {\n    return { ...options, type: 'TypeOf', value };\n  }\n}\n"],"names":["Expression","And","expressions","options","expr","globalThis","Array","isArray","length","False","type","Call","target","parameters","expression","Equals","value","Function","callback","ElementsDistinct","Elements","GreaterThanEqual","GreaterThan","IfThenElse","$if","$then","$else","if","then","else","Index","index","InstanceOf","IsArray","IsNaN","IsInteger","IsObject","TypeOf","IsBigInt","IsBoolean","IsFinite","IsFunction","IsNumber","IsSafeInteger","IsString","IsSymbol","IsUndefined","IsNull","IsPattern","pattern","KeyIn","LessThanEqual","LessThan","MultipleOf","Not","Or","PropertiesExcludePattern","PropertiesExclude","keys","PropertiesIncludePattern","PropertiesInclude","PropertiesLength","PropertiesMaximum","PropertiesMinimum","Properties","PropertyKeys","Property","key","Ref","$ref","True"],"mappings":"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"}

package/lib/schema/typebox/gen/codegen/expression/index.js

@@ -0,0 +1,32 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox-expression
+
+The MIT License (MIT)
+
+Copyright (c) 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.
+
+---------------------------------------------------------------------------*/ export * from './compiler.js';
+export * from './errors.js';
+export * from './evaluator.js';
+export * from './expression.js';
+
+//# sourceMappingURL=index.js.map

package/lib/schema/typebox/gen/codegen/expression/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/schema/typebox/gen/codegen/expression/index.ts"],"sourcesContent":["/*--------------------------------------------------------------------------\n\n@sinclair/typebox-expression\n\nThe MIT License (MIT)\n\nCopyright (c) 2023 Haydn Paterson (sinclair) <haydn.developer@gmail.com>\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n\n---------------------------------------------------------------------------*/\n\nexport * from './compiler';\nexport * from './errors';\nexport * from './evaluator';\nexport * from './expression';\n"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;2EA0B2E,GAE3E,cAAc,aAAa;AAC3B,cAAc,WAAW;AACzB,cAAc,cAAc;AAC5B,cAAc,eAAe"}

package/lib/schema/typebox/gen/codegen/index.js

@@ -0,0 +1,29 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox-codegen
+
+The MIT License (MIT)
+
+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.
+
+---------------------------------------------------------------------------*/ export * from './common/index.js';
+export * from './model/index.js';
+export * from './typescript/index.js';
+
+//# sourceMappingURL=index.js.map

package/lib/schema/typebox/gen/codegen/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../src/schema/typebox/gen/codegen/index.ts"],"sourcesContent":["/*--------------------------------------------------------------------------\n\n@sinclair/typebox-codegen\n\nThe MIT License (MIT)\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n\n---------------------------------------------------------------------------*/\n\nexport * from './common';\nexport * from './model';\nexport * from './typescript';\n"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;2EAwB2E,GAE3E,cAAc,WAAW;AACzB,cAAc,UAAU;AACxB,cAAc,eAAe"}

package/lib/schema/typebox/gen/codegen/model/index.js

@@ -0,0 +1,40 @@
+/*--------------------------------------------------------------------------
+
+@sinclair/typebox-codegen
+
+The MIT License (MIT)
+
+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.
+
+---------------------------------------------------------------------------*/ export * from './model-to-arktype.js';
+export * from './model-to-expression.js';
+export * from './model-to-grpc.js';
+export * from './model-to-io-ts.js';
+export * from './model-to-javascript.js';
+export * from './model-to-json-schema.js';
+export * from './model-to-typebox.js';
+export * from './model-to-typescript.js';
+export * from './model-to-valibot.js';
+export * from './model-to-value.js';
+export * from './model-to-yrel.js';
+export * from './model-to-yup.js';
+export * from './model-to-zod.js';
+export * from './model.js';
+
+//# sourceMappingURL=index.js.map

package/lib/schema/typebox/gen/codegen/model/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/schema/typebox/gen/codegen/model/index.ts"],"sourcesContent":["/*--------------------------------------------------------------------------\n\n@sinclair/typebox-codegen\n\nThe MIT License (MIT)\n\nPermission is hereby granted, free of charge, to any person obtaining a copy\nof this software and associated documentation files (the \"Software\"), to deal\nin the Software without restriction, including without limitation the rights\nto use, copy, modify, merge, publish, distribute, sublicense, and/or sell\ncopies of the Software, and to permit persons to whom the Software is\nfurnished to do so, subject to the following conditions:\n\nThe above copyright notice and this permission notice shall be included in\nall copies or substantial portions of the Software.\n\nTHE SOFTWARE IS PROVIDED \"AS IS\", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR\nIMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,\nFITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE\nAUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER\nLIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,\nOUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN\nTHE SOFTWARE.\n\n---------------------------------------------------------------------------*/\n\nexport * from './model-to-arktype';\nexport * from './model-to-expression';\nexport * from './model-to-grpc';\nexport * from './model-to-io-ts';\nexport * from './model-to-javascript';\nexport * from './model-to-json-schema';\nexport * from './model-to-typebox';\nexport * from './model-to-typescript';\nexport * from './model-to-valibot';\nexport * from './model-to-value';\nexport * from './model-to-yrel';\nexport * from './model-to-yup';\nexport * from './model-to-zod';\nexport * from './model';\n"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;2EAwB2E,GAE3E,cAAc,qBAAqB;AACnC,cAAc,wBAAwB;AACtC,cAAc,kBAAkB;AAChC,cAAc,mBAAmB;AACjC,cAAc,wBAAwB;AACtC,cAAc,yBAAyB;AACvC,cAAc,qBAAqB;AACnC,cAAc,wBAAwB;AACtC,cAAc,qBAAqB;AACnC,cAAc,mBAAmB;AACjC,cAAc,kBAAkB;AAChC,cAAc,iBAAiB;AAC/B,cAAc,iBAAiB;AAC/B,cAAc,UAAU"}