@briza/illogical 1.4.3 → 1.5.2

package/types/expression/comparison/ne.d.ts

@@ -1,22 +1,18 @@
-/**
- * Comparison expression module.
- * @module illogical/expression/comparison
- */
-import { Evaluable, Result } from '../../common/evaluable';
-import { Comparison } from '../comparison';
-export declare const OPERATOR: unique symbol;
-/**
- * Not equal comparison expression
- */
-export declare class NotEqual extends Comparison {
-    /**
-     * @constructor
-     * @param {Evaluable} left Left operand.
-     * @param {Evaluable} right Right operand.
-     */
-    constructor(...args: Evaluable[]);
-    /**
-     * {@link Comparison.comparison}
-     */
-    comparison(left: Result, right: Result): boolean;
-}
+import { Evaluable, Result } from '../../common/evaluable';
+import { Comparison } from '../comparison';
+export declare const OPERATOR: unique symbol;
+/**
+ * Not equal comparison expression
+ */
+export declare class NotEqual extends Comparison {
+    /**
+     * @constructor
+     * @param {Evaluable} left Left operand.
+     * @param {Evaluable} right Right operand.
+     */
+    constructor(...args: Evaluable[]);
+    /**
+     * {@link Comparison.comparison}
+     */
+    comparison(left: Result, right: Result): boolean;
+}

package/types/expression/comparison/not-in.d.ts

@@ -1,27 +1,23 @@
-/**
- * Comparison expression module.
- * @module illogical/expression/comparison
- */
-import { Evaluable, Result } from '../../common/evaluable';
-import { Comparison } from '../comparison';
-export declare const OPERATOR: unique symbol;
-/**
- * Not in comparison expression
- */
-export declare class NotIn extends Comparison {
-    /**
-     * @constructor
-     * @param {Evaluable} left Left operand.
-     * @param {Evaluable} right Right operand.
-     */
-    constructor(...args: Evaluable[]);
-    /**
-     * {@link Comparison.comparison}
-     */
-    comparison(left: Result, right: Result): boolean;
-    /**
-     * Get the strict representation of the expression
-     * @return {string}
-     */
-    toString(): string;
-}
+import { Evaluable, Result } from '../../common/evaluable';
+import { Comparison } from '../comparison';
+export declare const OPERATOR: unique symbol;
+/**
+ * Not in comparison expression
+ */
+export declare class NotIn extends Comparison {
+    /**
+     * @constructor
+     * @param {Evaluable} left Left operand.
+     * @param {Evaluable} right Right operand.
+     */
+    constructor(...args: Evaluable[]);
+    /**
+     * {@link Comparison.comparison}
+     */
+    comparison(left: Result, right: Result): boolean;
+    /**
+     * Get the strict representation of the expression
+     * @return {string}
+     */
+    toString(): string;
+}

package/types/expression/comparison/overlap.d.ts

@@ -1,27 +1,23 @@
-/**
- * Comparison expression module.
- * @module illogical/expression/comparison
- */
-import { Evaluable, Result } from '../../common/evaluable';
-import { Comparison } from '../comparison';
-export declare const OPERATOR: unique symbol;
-/**
- * Overlap comparison expression
- */
-export declare class Overlap extends Comparison {
-    /**
-     * @constructor
-     * @param {Evaluable} left Left operand.
-     * @param {Evaluable} right Right operand.
-     */
-    constructor(...args: Evaluable[]);
-    /**
-     * {@link Comparison.comparison}
-     */
-    comparison(left: Result, right: Result): boolean;
-    /**
-     * Get the strict representation of the expression.
-     * @return {string}
-     */
-    toString(): string;
-}
+import { Evaluable, Result } from '../../common/evaluable';
+import { Comparison } from '../comparison';
+export declare const OPERATOR: unique symbol;
+/**
+ * Overlap comparison expression
+ */
+export declare class Overlap extends Comparison {
+    /**
+     * @constructor
+     * @param {Evaluable} left Left operand.
+     * @param {Evaluable} right Right operand.
+     */
+    constructor(...args: Evaluable[]);
+    /**
+     * {@link Comparison.comparison}
+     */
+    comparison(left: Result, right: Result): boolean;
+    /**
+     * Get the strict representation of the expression.
+     * @return {string}
+     */
+    toString(): string;
+}

package/types/expression/comparison/prefix.d.ts

@@ -1,27 +1,23 @@
-/**
- * Prefix expression module.
- * @module illogical/expression/prefix
- */
-import { Evaluable, Result } from '../../common/evaluable';
-import { Comparison } from '../comparison';
-export declare const OPERATOR: unique symbol;
-/**
- * Prefix comparison expression
- */
-export declare class Prefix extends Comparison {
-    /**
-     * @constructor
-     * @param {Evaluable} left Left operand.
-     * @param {Evaluable} right Right operand.
-     */
-    constructor(...args: Evaluable[]);
-    /**
-     * {@link Comparison.comparison}
-     */
-    comparison(left: Result, right: Result): boolean;
-    /**
-     * Get the strict representation of the expression.
-     * @return {string}
-     */
-    toString(): string;
-}
+import { Evaluable, Result } from '../../common/evaluable';
+import { Comparison } from '../comparison';
+export declare const OPERATOR: unique symbol;
+/**
+ * Prefix comparison expression
+ */
+export declare class Prefix extends Comparison {
+    /**
+     * @constructor
+     * @param {Evaluable} left Left operand.
+     * @param {Evaluable} right Right operand.
+     */
+    constructor(...args: Evaluable[]);
+    /**
+     * {@link Comparison.comparison}
+     */
+    comparison(left: Result, right: Result): boolean;
+    /**
+     * Get the strict representation of the expression.
+     * @return {string}
+     */
+    toString(): string;
+}

package/types/expression/comparison/present.d.ts

@@ -1,29 +1,25 @@
-/**
- * Present expression module.
- * @module illogical/expression/comparison
- */
-import { Evaluable, Result } from '../../common/evaluable';
-import { ExpressionInput } from '../../parser';
-import { Options } from '../../parser/options';
-import { Comparison } from './index';
-export declare const OPERATOR: unique symbol;
-/**
- * Present comparison expression
- */
-export declare class Present extends Comparison {
-    /**
-     * @constructor
-     * @param {Evaluable} operand
-     */
-    constructor(...args: Evaluable[]);
-    /**
-     * {@link Comparison.comparison}
-     */
-    comparison(left: Result): boolean;
-    /**
-     * Get the strict representation of the expression.
-     * @return {string}
-     */
-    toString(): string;
-    serialize(options: Options): ExpressionInput;
-}
+import { Evaluable, Result } from '../../common/evaluable';
+import { ExpressionInput } from '../../parser';
+import { Options } from '../../parser/options';
+import { Comparison } from './index';
+export declare const OPERATOR: unique symbol;
+/**
+ * Present comparison expression
+ */
+export declare class Present extends Comparison {
+    /**
+     * @constructor
+     * @param {Evaluable} operand
+     */
+    constructor(...args: Evaluable[]);
+    /**
+     * {@link Comparison.comparison}
+     */
+    comparison(left: Result): boolean;
+    /**
+     * Get the strict representation of the expression.
+     * @return {string}
+     */
+    toString(): string;
+    serialize(options: Options): ExpressionInput;
+}

package/types/expression/comparison/suffix.d.ts

@@ -1,27 +1,23 @@
-/**
- * Suffix expression module.
- * @module illogical/expression/suffix
- */
-import { Evaluable, Result } from '../../common/evaluable';
-import { Comparison } from '../comparison';
-export declare const OPERATOR: unique symbol;
-/**
- * Suffix comparison expression
- */
-export declare class Suffix extends Comparison {
-    /**
-     * @constructor
-     * @param {Evaluable} left Left operand.
-     * @param {Evaluable} right Right operand.
-     */
-    constructor(...args: Evaluable[]);
-    /**
-     * {@link Comparison.comparison}
-     */
-    comparison(left: Result, right: Result): boolean;
-    /**
-     * Get the strict representation of the expression.
-     * @return {string}
-     */
-    toString(): string;
-}
+import { Evaluable, Result } from '../../common/evaluable';
+import { Comparison } from '../comparison';
+export declare const OPERATOR: unique symbol;
+/**
+ * Suffix comparison expression
+ */
+export declare class Suffix extends Comparison {
+    /**
+     * @constructor
+     * @param {Evaluable} left Left operand.
+     * @param {Evaluable} right Right operand.
+     */
+    constructor(...args: Evaluable[]);
+    /**
+     * {@link Comparison.comparison}
+     */
+    comparison(left: Result, right: Result): boolean;
+    /**
+     * Get the strict representation of the expression.
+     * @return {string}
+     */
+    toString(): string;
+}

package/types/expression/comparison/undefined.d.ts

@@ -1,32 +1,28 @@
-/**
- * Undefined expression module.
- * @module illogical/expression/comparison
- */
-import { Evaluable, Result } from '../../common/evaluable';
-import { ExpressionInput } from '../../parser';
-import { Options } from '../../parser/options';
-import { Comparison } from '../comparison';
-export declare const OPERATOR: unique symbol;
-/**
- * Undefined comparison expression
- */
-export declare class Undefined extends Comparison {
-    /**
-     * @constructor
-     * @param {Evaluable} operand
-     */
-    constructor(...args: Evaluable[]);
-    /**
-     * {@link Comparison.comparison}
-     */
-    comparison(left: Result): boolean;
-    /**
-     * Get the strict representation of the expression.
-     * @return {string}
-     */
-    toString(): string;
-    /**
-     * {@link Evaluable.serialize}
-     */
-    serialize(options: Options): ExpressionInput;
-}
+import { Evaluable, Result } from '../../common/evaluable';
+import { ExpressionInput } from '../../parser';
+import { Options } from '../../parser/options';
+import { Comparison } from '../comparison';
+export declare const OPERATOR: unique symbol;
+/**
+ * Undefined comparison expression
+ */
+export declare class Undefined extends Comparison {
+    /**
+     * @constructor
+     * @param {Evaluable} operand
+     */
+    constructor(...args: Evaluable[]);
+    /**
+     * {@link Comparison.comparison}
+     */
+    comparison(left: Result): boolean;
+    /**
+     * Get the strict representation of the expression.
+     * @return {string}
+     */
+    toString(): string;
+    /**
+     * {@link Evaluable.serialize}
+     */
+    serialize(options: Options): ExpressionInput;
+}

package/types/expression/logical/and.d.ts

@@ -1,27 +1,23 @@
-/**
- * Logical expression module.
- * @module illogical/expression/logical
- */
-import { Context, Evaluable, Result } from '../../common/evaluable';
-import { Logical } from '../logical';
-export declare const OPERATOR: unique symbol;
-/**
- * And logical expression
- */
-export declare class And extends Logical {
-    /**
-     * @constructor
-     * @param {Evaluable[]} operands Collection of operands.
-     */
-    constructor(operands: Evaluable[]);
-    /**
-     * Evaluate in the given context.
-     * @param {Context} ctx
-     * @return {Result}
-     */
-    evaluate(ctx: Context): Result;
-    /**
-     * {@link Evaluable.simplify}
-     */
-    simplify(...args: [Context, string[]]): boolean | Evaluable;
-}
+import { Context, Evaluable, Result, SimplifyArgs } from '../../common/evaluable';
+import { Logical } from '../logical';
+export declare const OPERATOR: unique symbol;
+/**
+ * And logical expression
+ */
+export declare class And extends Logical {
+    /**
+     * @constructor
+     * @param {Evaluable[]} operands Collection of operands.
+     */
+    constructor(operands: Evaluable[]);
+    /**
+     * Evaluate in the given context.
+     * @param {Context} ctx
+     * @return {Result}
+     */
+    evaluate(ctx: Context): Result;
+    /**
+     * {@link Evaluable.simplify}
+     */
+    simplify(...args: SimplifyArgs): boolean | Evaluable;
+}

package/types/expression/logical/index.d.ts

@@ -1,36 +1,32 @@
-/**
- * Logical expression module.
- * @module illogical/expression/logical
- */
-import { Context, Evaluable, EvaluableType, Result } from '../../common/evaluable';
-import { ExpressionInput } from '../../parser';
-import { Options } from '../../parser/options';
-/**
- * Abstract logical expression
- */
-export declare abstract class Logical implements Evaluable {
-    protected readonly operator: string;
-    protected readonly operatorSymbol: symbol;
-    protected readonly operands: Evaluable[];
-    type: EvaluableType;
-    /**
-     * @constructor
-     * @param {string} operator String representation of the operator.
-     * @param {Evaluable[]} operands Collection of operands.
-     */
-    constructor(operator: string, operatorSymbol: symbol, operands: Evaluable[]);
-    /**
-     * {@link Evaluable.evaluate}
-     */
-    abstract evaluate(ctx: Context): Result;
-    /**
-     * {@link Evaluable.simplify}
-     */
-    abstract simplify(ctx: Context, ignoreKeys: string[]): Result | Evaluable;
-    /**
-     * Get the strict representation of the expression.
-     * @return {string}
-     */
-    toString(): string;
-    serialize(options: Options): ExpressionInput;
-}
+import { Context, Evaluable, EvaluableType, Result } from '../../common/evaluable';
+import { ExpressionInput } from '../../parser';
+import { Options } from '../../parser/options';
+/**
+ * Abstract logical expression
+ */
+export declare abstract class Logical implements Evaluable {
+    protected readonly operator: string;
+    protected readonly operatorSymbol: symbol;
+    protected readonly operands: Evaluable[];
+    type: EvaluableType;
+    /**
+     * @constructor
+     * @param {string} operator String representation of the operator.
+     * @param {Evaluable[]} operands Collection of operands.
+     */
+    constructor(operator: string, operatorSymbol: symbol, operands: Evaluable[]);
+    /**
+     * {@link Evaluable.evaluate}
+     */
+    abstract evaluate(ctx: Context): Result;
+    /**
+     * {@link Evaluable.simplify}
+     */
+    abstract simplify(ctx: Context, strictKeys?: string[], optionalKeys?: string[]): Result | Evaluable;
+    /**
+     * Get the strict representation of the expression.
+     * @return {string}
+     */
+    toString(): string;
+    serialize(options: Options): ExpressionInput;
+}

package/types/expression/logical/nor.d.ts

@@ -1,27 +1,23 @@
-/**
- * Logical expression module.
- * @module illogical/expression/logical
- */
-import { Context, Evaluable, Result } from '../../common/evaluable';
-import { Logical } from '../logical';
-export declare const OPERATOR: unique symbol;
-/**
- * Nor logical expression
- */
-export declare class Nor extends Logical {
-    /**
-     * @constructor
-     * @param {Evaluable[]} operands Collection of operands.
-     */
-    constructor(operands: Evaluable[]);
-    /**
-     * Evaluate in the given context.
-     * @param {Context} ctx
-     * @return {Result}
-     */
-    evaluate(ctx: Context): Result;
-    /**
-     * {@link Evaluable.simplify}
-     */
-    simplify(...args: [Context, string[]]): boolean | Evaluable;
-}
+import { Context, Evaluable, Result, SimplifyArgs } from '../../common/evaluable';
+import { Logical } from '../logical';
+export declare const OPERATOR: unique symbol;
+/**
+ * Nor logical expression
+ */
+export declare class Nor extends Logical {
+    /**
+     * @constructor
+     * @param {Evaluable[]} operands Collection of operands.
+     */
+    constructor(operands: Evaluable[]);
+    /**
+     * Evaluate in the given context.
+     * @param {Context} ctx
+     * @return {Result}
+     */
+    evaluate(ctx: Context): Result;
+    /**
+     * {@link Evaluable.simplify}
+     */
+    simplify(...args: SimplifyArgs): boolean | Evaluable;
+}

package/types/expression/logical/not.d.ts

@@ -1,27 +1,23 @@
-/**
- * Logical expression module.
- * @module illogical/expression/logical
- */
-import { Context, Evaluable, Result } from '../../common/evaluable';
-import { Logical } from '.';
-export declare const OPERATOR: unique symbol;
-/**
- * Not logical expression
- */
-export declare class Not extends Logical {
-    /**
-     * @constructor
-     * @param {Evaluable} operand
-     */
-    constructor(...args: Evaluable[]);
-    /**
-     * Evaluate in the given context.
-     * @param {Context} ctx
-     * @return {Result}
-     */
-    evaluate(ctx: Context): Result;
-    /**
-     * {@link Evaluable.simplify}
-     */
-    simplify(...args: [Context, string[]]): boolean | Evaluable;
-}
+import { Context, Evaluable, Result, SimplifyArgs } from '../../common/evaluable';
+import { Logical } from '.';
+export declare const OPERATOR: unique symbol;
+/**
+ * Not logical expression
+ */
+export declare class Not extends Logical {
+    /**
+     * @constructor
+     * @param {Evaluable} operand
+     */
+    constructor(...args: Evaluable[]);
+    /**
+     * Evaluate in the given context.
+     * @param {Context} ctx
+     * @return {Result}
+     */
+    evaluate(ctx: Context): Result;
+    /**
+     * {@link Evaluable.simplify}
+     */
+    simplify(...args: SimplifyArgs): boolean | Evaluable;
+}

package/types/expression/logical/or.d.ts

@@ -1,27 +1,23 @@
-/**
- * Logical expression module.
- * @module illogical/expression/logical
- */
-import { Context, Evaluable, Result } from '../../common/evaluable';
-import { Logical } from '../logical';
-export declare const OPERATOR: unique symbol;
-/**
- * Or logical expression
- */
-export declare class Or extends Logical {
-    /**
-     * @constructor
-     * @param {Evaluable[]} operands Collection of operands.
-     */
-    constructor(operands: Evaluable[]);
-    /**
-     * Evaluate in the given context.
-     * @param {Context} ctx
-     * @return {Result}
-     */
-    evaluate(ctx: Context): Result;
-    /**
-     * {@link Evaluable.simplify}
-     */
-    simplify(...args: [Context, string[]]): boolean | Evaluable;
-}
+import { Context, Evaluable, Result, SimplifyArgs } from '../../common/evaluable';
+import { Logical } from '../logical';
+export declare const OPERATOR: unique symbol;
+/**
+ * Or logical expression
+ */
+export declare class Or extends Logical {
+    /**
+     * @constructor
+     * @param {Evaluable[]} operands Collection of operands.
+     */
+    constructor(operands: Evaluable[]);
+    /**
+     * Evaluate in the given context.
+     * @param {Context} ctx
+     * @return {Result}
+     */
+    evaluate(ctx: Context): Result;
+    /**
+     * {@link Evaluable.simplify}
+     */
+    simplify(...args: SimplifyArgs): boolean | Evaluable;
+}