@rsconcept/domain 1.0.0 → 1.2.0

package/dist/rslang/semantic/value-auditor.js

@@ -1,523 +1,211 @@
-// src/parsing/ast.ts
-var TOKEN_ERROR = 0;
-function getNodeText(node) {
-  if (node.data.dataType === "string" && typeof node.data.value === "string") {
-    return node.data.value;
-  }
-  return `NO DATA NODE: ${node.typeID}`;
-}
-
-// src/rslang/ast-annotations.ts
-var AST_ERRORS_KEY = "rsErrors";
-function annotateError(node, code, params) {
-  if (typeof node.annotation === "object" && node.annotation !== null && AST_ERRORS_KEY in node.annotation && isAstNodeErrorRef(node.annotation[AST_ERRORS_KEY])) {
-    return;
-  }
-  const entry = params !== void 0 && params.length > 0 ? { code, params: [...params] } : { code };
-  node.annotation = {
-    ...typeof node.annotation === "object" && node.annotation !== null ? node.annotation : {},
-    [AST_ERRORS_KEY]: entry
-  };
-}
-function isAstNodeErrorRef(x) {
-  if (typeof x !== "object" || x === null || !("code" in x)) {
-    return false;
-  }
-  const code = x.code;
-  if (typeof code !== "number") {
-    return false;
-  }
-  if (!("params" in x)) {
-    return true;
-  }
-  const p = x.params;
-  if (p === void 0) {
-    return true;
-  }
-  return Array.isArray(p) && p.every((item) => typeof item === "string");
-}
-
-// src/rslang/error.ts
-var RSErrorCode = {
-  unknownSyntax: 33792,
-  // 33792
-  missingParenthesis: 33798,
-  // 33798
-  missingCurlyBrace: 33799,
-  // 33799
-  missingSquareBracket: 33800,
-  // 33800
-  bracketMismatch: 33801,
-  // 33801
-  doubleParenthesis: 33802,
-  // 33802
-  missingOpenBracket: 33803,
-  // 33803
-  expectedLocal: 33813,
-  // 33813
-  expectedType: 33814,
-  // 33814
-  localDoubleDeclare: 10241,
-  // 10241
-  localNotUsed: 10242,
-  // 10242
-  localUndeclared: 34817,
-  // 34817
-  localShadowing: 34818,
-  // 34818
-  typesNotEqual: 34819,
-  // 34819
-  globalNotTyped: 34820,
-  // 34820
-  invalidDecart: 34821,
-  // 34821
-  invalidBoolean: 34822,
-  // 34822
-  invalidTypeOperation: 34823,
-  // 34823
-  invalidCard: 34824,
-  // 34824
-  invalidDebool: 34825,
-  // 34825
-  globalFuncWithoutArgs: 34827,
-  // 34827
-  invalidReduce: 34832,
-  // 34832
-  invalidProjectionTuple: 34833,
-  // 34833
-  invalidProjectionSet: 34834,
-  // 34834
-  invalidEnumeration: 34835,
-  // 34835
-  invalidCortegeDeclare: 34836,
-  // 34836
-  localOutOfScope: 34837,
-  // 34837
-  invalidElementPredicate: 34838,
-  // 34838
-  invalidEmptySetUsage: 34839,
-  // 34839
-  invalidArgsArity: 34840,
-  // 34840
-  invalidArgumentType: 34841,
-  // 34841
-  globalStructure: 34844,
-  // 34844
-  radicalUsage: 34849,
-  // 34849
-  invalidFilterArgumentType: 34850,
-  // 34850
-  invalidFilterArity: 34851,
-  // 34851
-  arithmeticNotSupported: 34852,
-  // 34852
-  typesNotCompatible: 34853,
-  // 34853
-  orderingNotSupported: 34854,
-  // 34854
-  expectedLogic: 34855,
-  // 34855
-  expectedSetexpr: 34856,
-  // 34856
-  invalidArgumentCortegeDeclare: 34857,
-  // 34857
-  globalNoValue: 34880,
-  // 34880
-  invalidPropertyUsage: 34881,
-  // 34881
-  // Value evaluation (runtime)
-  calcUnknownError: 33024,
-  // 35328
-  setOverflow: 33025,
-  // 35329
-  booleanBaseLimit: 33026,
-  // 35330
-  calcGlobalMissing: 33027,
-  // 35331
-  iterationsLimit: 33028,
-  // 35332
-  calcInvalidDebool: 33029,
-  // 35333
-  iterateInfinity: 33030,
-  // 35334
-  calculationNotSupported: 33031,
-  // 35335
-  cstEmptyDerived: 34913,
-  // 34913
-  definitionNotAllowed: 34914
-  // 34914
-};
-
-// src/rslang/parser/token.ts
-var TokenID = {
-  // Global, local IDs and literals
-  ERROR: TOKEN_ERROR,
-  ID_LOCAL: 258,
-  ID_GLOBAL: 259,
-  ID_FUNCTION: 260,
-  ID_PREDICATE: 261,
-  ID_RADICAL: 262,
-  LIT_INTEGER: 263,
-  LIT_WHOLE_NUMBERS: 264,
-  LIT_EMPTYSET: 265,
-  // Arithmetic
-  PLUS: 266,
-  MINUS: 267,
-  MULTIPLY: 268,
-  // Integer predicate symbols
-  GREATER: 269,
-  LESSER: 270,
-  GREATER_OR_EQ: 271,
-  LESSER_OR_EQ: 272,
-  // Equality comparison
-  EQUAL: 273,
-  NOTEQUAL: 274,
-  // Logic predicate symbols
-  QUANTOR_UNIVERSAL: 275,
-  QUANTOR_EXISTS: 276,
-  LOGIC_NOT: 277,
-  LOGIC_EQUIVALENT: 278,
-  LOGIC_IMPLICATION: 279,
-  LOGIC_OR: 280,
-  LOGIC_AND: 281,
-  // Set theory predicate symbols
-  SET_IN: 282,
-  SET_NOT_IN: 283,
-  SUBSET: 284,
-  SUBSET_OR_EQ: 285,
-  NOT_SUBSET: 286,
-  // Set theory operators
-  DECART: 287,
-  SET_UNION: 288,
-  SET_INTERSECTION: 289,
-  SET_MINUS: 290,
-  SET_SYMMETRIC_MINUS: 291,
-  BOOLEAN: 292,
-  // Structure operations
-  BIGPR: 293,
-  SMALLPR: 294,
-  FILTER: 295,
-  CARD: 296,
-  BOOL: 297,
-  DEBOOL: 298,
-  REDUCE: 299,
-  // Term constructions prefixes
-  DECLARATIVE: 300,
-  RECURSIVE: 301,
-  IMPERATIVE: 302,
-  ITERATE: 303,
-  ASSIGN: 304,
-  // Punctuation
-  PUNCTUATION_DEFINE: 305,
-  PUNCTUATION_STRUCT: 306,
-  PUNCTUATION_PL: 307,
-  PUNCTUATION_PR: 308,
-  PUNCTUATION_CL: 309,
-  PUNCTUATION_CR: 310,
-  PUNCTUATION_SL: 311,
-  PUNCTUATION_SR: 312,
-  PUNCTUATION_BAR: 313,
-  PUNCTUATION_COMMA: 314,
-  PUNCTUATION_SEMICOLON: 315,
-  // ======= Non-terminal tokens =========
-  NT_ENUM_DECL: 316,
-  NT_TUPLE: 317,
-  NT_ENUMERATION: 318,
-  NT_TUPLE_DECL: 319,
-  NT_ARG_DECL: 320,
-  NT_FUNC_DEFINITION: 321,
-  NT_ARGUMENTS: 322,
-  NT_FUNC_CALL: 323,
-  NT_DECLARATIVE_EXPR: 324,
-  NT_IMPERATIVE_EXPR: 325,
-  NT_RECURSIVE_FULL: 326,
-  NT_RECURSIVE_SHORT: 327,
-  // ======= Helper tokens ========
-  INTERRUPT: 328,
-  END: 329
-};
-
-// src/rslang/semantic/value-class.ts
-var ValueClass = {
-  VALUE: "value",
-  PROPERTY: "property"
-};
-
-// src/rslang/semantic/value-auditor.ts
+import { annotateError } from "../ast-annotations.js";
+import { RSErrorCode } from "../error.js";
+import { getNodeText } from "../../parsing/ast.js";
+import "../../parsing/index.js";
+import { TokenID } from "../parser/token.js";
+import { ValueClass } from "./value-class.js";
+//#region src/rslang/semantic/value-auditor.ts
+/**
+* Module: Value auditor for AST value class checking.
+*
+* Determines whether an expression yields a concrete value (computable)
+* or a property (e.g., depends on a quantified variable).
+*/
+/** Value auditor for AST value class checking. */
 var ValueAuditor = class {
-  context;
-  annotateErrors;
-  reporter;
-  constructor(context) {
-    this.context = context;
-    this.annotateErrors = false;
-  }
-  /**
-   * Runs value audit on the AST. Returns the value class on success, null on failure.
-   */
-  run(ast, reporter, annotateErrors = false) {
-    if (ast.hasError) {
-      return null;
-    }
-    this.reporter = reporter;
-    this.annotateErrors = annotateErrors;
-    return this.dispatchVisit(ast);
-  }
-  dispatchVisit(node) {
-    switch (node.typeID) {
-      case TokenID.ID_GLOBAL:
-      case TokenID.ID_FUNCTION:
-      case TokenID.ID_PREDICATE:
-        return this.visitGlobal(node);
-      case TokenID.ID_LOCAL:
-      case TokenID.ID_RADICAL:
-      case TokenID.LIT_INTEGER:
-      case TokenID.LIT_EMPTYSET:
-        return ValueClass.VALUE;
-      case TokenID.LIT_WHOLE_NUMBERS:
-        return ValueClass.PROPERTY;
-      case TokenID.NT_TUPLE_DECL:
-      case TokenID.NT_ENUM_DECL:
-        return this.visitAllAndReturn(node, ValueClass.VALUE);
-      case TokenID.NT_ARGUMENTS:
-      case TokenID.NT_ARG_DECL:
-        return this.visitAllAndReturn(node, ValueClass.VALUE);
-      case TokenID.PLUS:
-      case TokenID.MINUS:
-      case TokenID.MULTIPLY:
-        return this.visitAllAndReturn(node, ValueClass.VALUE);
-      case TokenID.QUANTOR_UNIVERSAL:
-      case TokenID.QUANTOR_EXISTS:
-        return this.visitQuantifier(node);
-      case TokenID.LOGIC_NOT:
-      case TokenID.LOGIC_AND:
-      case TokenID.LOGIC_OR:
-      case TokenID.LOGIC_IMPLICATION:
-      case TokenID.LOGIC_EQUIVALENT:
-        return this.visitAllAndReturn(node, ValueClass.VALUE);
-      case TokenID.EQUAL:
-      case TokenID.NOTEQUAL:
-        return this.assertAllValues(node);
-      case TokenID.GREATER:
-      case TokenID.LESSER:
-      case TokenID.GREATER_OR_EQ:
-      case TokenID.LESSER_OR_EQ:
-        return this.visitAllAndReturn(node, ValueClass.VALUE);
-      case TokenID.SET_IN:
-      case TokenID.SET_NOT_IN:
-      case TokenID.SUBSET:
-      case TokenID.SUBSET_OR_EQ:
-      case TokenID.NOT_SUBSET:
-        return this.visitSetexprPredicate(node);
-      case TokenID.DECART:
-        return this.visitDecart(node);
-      case TokenID.BOOLEAN:
-        return this.visitBoolean(node);
-      case TokenID.NT_TUPLE:
-      case TokenID.NT_ENUMERATION:
-        return this.assertAllValues(node);
-      case TokenID.FILTER:
-        return this.visitFilter(node);
-      case TokenID.CARD:
-      case TokenID.BOOL:
-      case TokenID.DEBOOL:
-      case TokenID.BIGPR:
-      case TokenID.SMALLPR:
-      case TokenID.REDUCE:
-        return this.assertChildIsValue(node, 0);
-      case TokenID.SET_UNION:
-      case TokenID.SET_INTERSECTION:
-      case TokenID.SET_MINUS:
-      case TokenID.SET_SYMMETRIC_MINUS:
-        return this.visitSetexprBinary(node);
-      case TokenID.NT_FUNC_DEFINITION:
-        return this.visitFunctionDefinition(node);
-      case TokenID.NT_FUNC_CALL:
-        return this.visitFunctionCall(node);
-      case TokenID.NT_DECLARATIVE_EXPR:
-        return this.visitDeclarative(node);
-      case TokenID.NT_IMPERATIVE_EXPR:
-        return this.visitImperative(node);
-      case TokenID.NT_RECURSIVE_FULL:
-      case TokenID.NT_RECURSIVE_SHORT:
-        return this.assertAllValues(node);
-      case TokenID.ITERATE:
-      case TokenID.ASSIGN:
-        return this.visitIterateOrAssign(node);
-    }
-    return null;
-  }
-  onError(code, node, params) {
-    this.reporter?.({ code, from: node.from, to: node.to, params });
-    if (this.annotateErrors) {
-      annotateError(node, code, params);
-    }
-    return null;
-  }
-  visitChild(node, index) {
-    return this.dispatchVisit(node.children[index]);
-  }
-  visitAllAndReturn(node, value) {
-    for (const child of node.children) {
-      if (this.dispatchVisit(child) === null) {
-        return null;
-      }
-    }
-    return value;
-  }
-  assertChildIsValue(node, index) {
-    const result = this.visitChild(node, index);
-    if (result === null) {
-      return null;
-    }
-    if (result !== ValueClass.VALUE) {
-      const child = node.children[index];
-      return this.onError(RSErrorCode.invalidPropertyUsage, child ?? node);
-    }
-    return ValueClass.VALUE;
-  }
-  assertAllValues(node) {
-    for (let i = 0; i < node.children.length; i++) {
-      if (this.assertChildIsValue(node, i) === null) {
-        return null;
-      }
-    }
-    return ValueClass.VALUE;
-  }
-  visitFunctionDefinition(node) {
-    if (this.visitChild(node, 0) === null) {
-      return null;
-    }
-    return this.visitChild(node, 1);
-  }
-  visitFunctionCall(node) {
-    const result = this.visitChild(node, 0);
-    if (result === null) {
-      return null;
-    }
-    for (let child = 1; child < node.children.length; child++) {
-      if (this.assertChildIsValue(node, child) === null) {
-        return null;
-      }
-    }
-    return result;
-  }
-  visitGlobal(node) {
-    const alias = getNodeText(node);
-    const result = this.context.get(alias);
-    if (!result) {
-      return this.onError(RSErrorCode.globalNoValue, node, [alias]);
-    }
-    return result;
-  }
-  visitQuantifier(node) {
-    if (this.assertChildIsValue(node, 1) === null) {
-      return null;
-    }
-    if (this.visitChild(node, 2) === null) {
-      return null;
-    }
-    return ValueClass.VALUE;
-  }
-  visitSetexprPredicate(node) {
-    const tokenId = node.typeID;
-    switch (tokenId) {
-      case TokenID.SET_IN:
-      case TokenID.SET_NOT_IN:
-      case TokenID.SUBSET_OR_EQ:
-        if (this.assertChildIsValue(node, 0) === null) {
-          return null;
-        }
-        if (this.visitChild(node, 1) === null) {
-          return null;
-        }
-        return ValueClass.VALUE;
-      case TokenID.SUBSET:
-      case TokenID.NOT_SUBSET:
-        return this.assertAllValues(node);
-    }
-    return null;
-  }
-  visitDeclarative(node) {
-    if (this.visitChild(node, 2) === null) {
-      return null;
-    }
-    return this.visitChild(node, 1);
-  }
-  visitImperative(node) {
-    for (let child = 1; child < node.children.length; child++) {
-      if (this.visitChild(node, child) === null) {
-        return null;
-      }
-    }
-    return this.assertChildIsValue(node, 0);
-  }
-  visitIterateOrAssign(node) {
-    if (this.visitChild(node, 0) === null) {
-      return null;
-    }
-    return this.assertChildIsValue(node, 1);
-  }
-  visitDecart(node) {
-    let result = ValueClass.VALUE;
-    for (let child = 0; child < node.children.length; child++) {
-      const childClass = this.visitChild(node, child);
-      if (childClass === null) {
-        return null;
-      }
-      if (childClass === ValueClass.PROPERTY) {
-        result = ValueClass.PROPERTY;
-      }
-    }
-    return result;
-  }
-  visitBoolean(node) {
-    if (this.visitChild(node, 0) === null) {
-      return null;
-    }
-    return ValueClass.PROPERTY;
-  }
-  visitFilter(node) {
-    let last = null;
-    for (const child of node.children) {
-      last = this.dispatchVisit(child);
-      if (last === null) {
-        return null;
-      }
-    }
-    return last;
-  }
-  visitSetexprBinary(node) {
-    const first = this.visitChild(node, 0);
-    if (first === null) {
-      return null;
-    }
-    const second = this.visitChild(node, 1);
-    if (second === null) {
-      return null;
-    }
-    const isValue = combineOperationValues(
-      node.typeID,
-      first === ValueClass.VALUE,
-      second === ValueClass.VALUE
-    );
-    return isValue ? ValueClass.VALUE : ValueClass.PROPERTY;
-  }
+	context;
+	annotateErrors;
+	reporter;
+	constructor(context) {
+		this.context = context;
+		this.annotateErrors = false;
+	}
+	/**
+	* Runs value audit on the AST. Returns the value class on success, null on failure.
+	*/
+	run(ast, reporter, annotateErrors = false) {
+		if (ast.hasError) return null;
+		this.reporter = reporter;
+		this.annotateErrors = annotateErrors;
+		return this.dispatchVisit(ast);
+	}
+	dispatchVisit(node) {
+		switch (node.typeID) {
+			case TokenID.ID_GLOBAL:
+			case TokenID.ID_FUNCTION:
+			case TokenID.ID_PREDICATE: return this.visitGlobal(node);
+			case TokenID.ID_LOCAL:
+			case TokenID.ID_RADICAL:
+			case TokenID.LIT_INTEGER:
+			case TokenID.LIT_EMPTYSET: return ValueClass.VALUE;
+			case TokenID.LIT_WHOLE_NUMBERS: return ValueClass.PROPERTY;
+			case TokenID.NT_TUPLE_DECL:
+			case TokenID.NT_ENUM_DECL: return this.visitAllAndReturn(node, ValueClass.VALUE);
+			case TokenID.NT_ARGUMENTS:
+			case TokenID.NT_ARG_DECL: return this.visitAllAndReturn(node, ValueClass.VALUE);
+			case TokenID.PLUS:
+			case TokenID.MINUS:
+			case TokenID.MULTIPLY: return this.visitAllAndReturn(node, ValueClass.VALUE);
+			case TokenID.QUANTOR_UNIVERSAL:
+			case TokenID.QUANTOR_EXISTS: return this.visitQuantifier(node);
+			case TokenID.LOGIC_NOT:
+			case TokenID.LOGIC_AND:
+			case TokenID.LOGIC_OR:
+			case TokenID.LOGIC_IMPLICATION:
+			case TokenID.LOGIC_EQUIVALENT: return this.visitAllAndReturn(node, ValueClass.VALUE);
+			case TokenID.EQUAL:
+			case TokenID.NOTEQUAL: return this.assertAllValues(node);
+			case TokenID.GREATER:
+			case TokenID.LESSER:
+			case TokenID.GREATER_OR_EQ:
+			case TokenID.LESSER_OR_EQ: return this.visitAllAndReturn(node, ValueClass.VALUE);
+			case TokenID.SET_IN:
+			case TokenID.SET_NOT_IN:
+			case TokenID.SUBSET:
+			case TokenID.SUBSET_OR_EQ:
+			case TokenID.NOT_SUBSET: return this.visitSetexprPredicate(node);
+			case TokenID.DECART: return this.visitDecart(node);
+			case TokenID.BOOLEAN: return this.visitBoolean(node);
+			case TokenID.NT_TUPLE:
+			case TokenID.NT_ENUMERATION: return this.assertAllValues(node);
+			case TokenID.FILTER: return this.visitFilter(node);
+			case TokenID.CARD:
+			case TokenID.BOOL:
+			case TokenID.DEBOOL:
+			case TokenID.BIGPR:
+			case TokenID.SMALLPR:
+			case TokenID.REDUCE: return this.assertChildIsValue(node, 0);
+			case TokenID.SET_UNION:
+			case TokenID.SET_INTERSECTION:
+			case TokenID.SET_MINUS:
+			case TokenID.SET_SYMMETRIC_MINUS: return this.visitSetexprBinary(node);
+			case TokenID.NT_FUNC_DEFINITION: return this.visitFunctionDefinition(node);
+			case TokenID.NT_FUNC_CALL: return this.visitFunctionCall(node);
+			case TokenID.NT_DECLARATIVE_EXPR: return this.visitDeclarative(node);
+			case TokenID.NT_IMPERATIVE_EXPR: return this.visitImperative(node);
+			case TokenID.NT_RECURSIVE_FULL:
+			case TokenID.NT_RECURSIVE_SHORT: return this.assertAllValues(node);
+			case TokenID.ITERATE:
+			case TokenID.ASSIGN: return this.visitIterateOrAssign(node);
+		}
+		return null;
+	}
+	onError(code, node, params) {
+		this.reporter?.({
+			code,
+			from: node.from,
+			to: node.to,
+			params
+		});
+		if (this.annotateErrors) annotateError(node, code, params);
+		return null;
+	}
+	visitChild(node, index) {
+		return this.dispatchVisit(node.children[index]);
+	}
+	visitAllAndReturn(node, value) {
+		for (const child of node.children) if (this.dispatchVisit(child) === null) return null;
+		return value;
+	}
+	assertChildIsValue(node, index) {
+		const result = this.visitChild(node, index);
+		if (result === null) return null;
+		if (result !== ValueClass.VALUE) {
+			const child = node.children[index];
+			return this.onError(RSErrorCode.invalidPropertyUsage, child ?? node);
+		}
+		return ValueClass.VALUE;
+	}
+	assertAllValues(node) {
+		for (let i = 0; i < node.children.length; i++) if (this.assertChildIsValue(node, i) === null) return null;
+		return ValueClass.VALUE;
+	}
+	visitFunctionDefinition(node) {
+		if (this.visitChild(node, 0) === null) return null;
+		return this.visitChild(node, 1);
+	}
+	visitFunctionCall(node) {
+		const result = this.visitChild(node, 0);
+		if (result === null) return null;
+		for (let child = 1; child < node.children.length; child++) if (this.assertChildIsValue(node, child) === null) return null;
+		return result;
+	}
+	visitGlobal(node) {
+		const alias = getNodeText(node);
+		const result = this.context.get(alias);
+		if (!result) return this.onError(RSErrorCode.globalNoValue, node, [alias]);
+		return result;
+	}
+	visitQuantifier(node) {
+		if (this.assertChildIsValue(node, 1) === null) return null;
+		if (this.visitChild(node, 2) === null) return null;
+		return ValueClass.VALUE;
+	}
+	visitSetexprPredicate(node) {
+		switch (node.typeID) {
+			case TokenID.SET_IN:
+			case TokenID.SET_NOT_IN:
+			case TokenID.SUBSET_OR_EQ:
+				if (this.assertChildIsValue(node, 0) === null) return null;
+				if (this.visitChild(node, 1) === null) return null;
+				return ValueClass.VALUE;
+			case TokenID.SUBSET:
+			case TokenID.NOT_SUBSET: return this.assertAllValues(node);
+		}
+		return null;
+	}
+	visitDeclarative(node) {
+		if (this.visitChild(node, 2) === null) return null;
+		return this.visitChild(node, 1);
+	}
+	visitImperative(node) {
+		for (let child = 1; child < node.children.length; child++) if (this.visitChild(node, child) === null) return null;
+		return this.assertChildIsValue(node, 0);
+	}
+	visitIterateOrAssign(node) {
+		if (this.visitChild(node, 0) === null) return null;
+		return this.assertChildIsValue(node, 1);
+	}
+	visitDecart(node) {
+		let result = ValueClass.VALUE;
+		for (let child = 0; child < node.children.length; child++) {
+			const childClass = this.visitChild(node, child);
+			if (childClass === null) return null;
+			if (childClass === ValueClass.PROPERTY) result = ValueClass.PROPERTY;
+		}
+		return result;
+	}
+	visitBoolean(node) {
+		if (this.visitChild(node, 0) === null) return null;
+		return ValueClass.PROPERTY;
+	}
+	visitFilter(node) {
+		let last = null;
+		for (const child of node.children) {
+			last = this.dispatchVisit(child);
+			if (last === null) return null;
+		}
+		return last;
+	}
+	visitSetexprBinary(node) {
+		const first = this.visitChild(node, 0);
+		if (first === null) return null;
+		const second = this.visitChild(node, 1);
+		if (second === null) return null;
+		return combineOperationValues(node.typeID, first === ValueClass.VALUE, second === ValueClass.VALUE) ? ValueClass.VALUE : ValueClass.PROPERTY;
+	}
 };
+/** Combines value flags for set operations. */
 function combineOperationValues(op, v1, v2) {
-  switch (op) {
-    case TokenID.SET_SYMMETRIC_MINUS:
-    case TokenID.SET_UNION:
-      return v1 && v2;
-    case TokenID.SET_INTERSECTION:
-      return v1 || v2;
-    case TokenID.SET_MINUS:
-      return v1;
-    default:
-      return v1 && v2;
-  }
+	switch (op) {
+		case TokenID.SET_SYMMETRIC_MINUS:
+		case TokenID.SET_UNION: return v1 && v2;
+		case TokenID.SET_INTERSECTION: return v1 || v2;
+		case TokenID.SET_MINUS: return v1;
+		default: return v1 && v2;
+	}
 }
-export {
-  ValueAuditor
-};
+//#endregion
+export { ValueAuditor };
+
 //# sourceMappingURL=value-auditor.js.map