@rsconcept/domain 1.0.0 → 1.2.0

package/dist/rslang/eval/value-api.js

@@ -1,490 +1,2 @@
-// src/shared/hash.ts
-function applyHash_fnv1a(str) {
-  let hash = 2166136261;
-  for (let i = 0; i < str.length; i++) {
-    hash ^= str.charCodeAt(i);
-    hash = Math.imul(hash, 16777619);
-  }
-  return hash >>> 0;
-}
-function generateStub(text) {
-  const hash = applyHash_fnv1a(text);
-  return hash.toString(16).padStart(8, "0").slice(0, 8);
-}
-
-// src/rslang/semantic/typification.ts
-var TypeID = {
-  anyTypification: 1,
-  integer: 2,
-  basic: 3,
-  tuple: 4,
-  collection: 5,
-  logic: 6,
-  function: 7,
-  predicate: 8
-};
-var LogicT = { typeID: TypeID.logic };
-var IntegerT = {
-  typeID: TypeID.integer,
-  isOrdered: true,
-  isArithmetic: true,
-  isIntegerCompatible: true
-};
-var AnyTypificationT = { typeID: TypeID.anyTypification };
-var EmptySetT = bool(AnyTypificationT);
-function bool(base) {
-  return { typeID: TypeID.collection, base };
-}
-
-// src/rslang/eval/value.ts
-var TUPLE_ID = -111;
-var INVALID_ELEMENT = -1;
-var VALUE_TRUE = 1;
-var VALUE_FALSE = 0;
-var SET_INFINITY = 1e7;
-var BOOL_INFINITY = 18;
-function makeValuePath(path) {
-  return path;
-}
-var EmptySetV = [];
-function compare(v1, v2) {
-  const stack1 = [v1];
-  const stack2 = [v2];
-  while (stack1.length > 0 && stack2.length > 0) {
-    const el1 = stack1.pop();
-    const el2 = stack2.pop();
-    if (el1 === el2) {
-      continue;
-    }
-    const type1 = typeof el1;
-    const type2 = typeof el2;
-    if (type1 === "number" && type2 === "number") {
-      const numDiff = el1 - el2;
-      if (numDiff !== 0) return numDiff;
-      continue;
-    }
-    const isArray1 = Array.isArray(el1);
-    const isArray2 = Array.isArray(el2);
-    if (!isArray1 || !isArray2) {
-      throw new Error(`Cannot compare different types ${printValue(el1)} and ${printValue(el2)}`);
-    }
-    const arr1 = el1;
-    const arr2 = el2;
-    const len1 = arr1.length;
-    const len2 = arr2.length;
-    if (len1 !== len2) {
-      return len1 - len2;
-    }
-    for (let i = len1 - 1; i >= 0; i--) {
-      stack1.push(arr1[i]);
-      stack2.push(arr2[i]);
-    }
-  }
-  return 0;
-}
-function tuple(components) {
-  return [TUPLE_ID, ...components];
-}
-function set(elements) {
-  const sorted = [...elements].sort(compare);
-  for (let i = 1; i < sorted.length; ) {
-    if (compare(sorted[i - 1], sorted[i]) === 0) {
-      sorted.splice(i, 1);
-    } else {
-      i++;
-    }
-  }
-  return sorted;
-}
-
-// src/rslang/eval/value-api.ts
-function cartesianProduct(factors) {
-  const cardinality = factors.reduce((acc, f) => acc * f.length, 1);
-  if (cardinality > SET_INFINITY) {
-    return null;
-  }
-  if (cardinality === 0 || factors.length === 0) {
-    return EmptySetV;
-  }
-  let accumulator = [[]];
-  for (const factor of factors) {
-    const next = [];
-    for (const prefix of accumulator) {
-      for (const value of factor) {
-        next.push([...prefix, value]);
-      }
-    }
-    accumulator = next;
-  }
-  return accumulator.map(tuple);
-}
-function boolean(base) {
-  if (base.length > BOOL_INFINITY) {
-    return null;
-  }
-  return powerset(base);
-}
-function powerset(arr) {
-  const result = [[]];
-  if (arr.length === 0) {
-    return result;
-  }
-  let current = [[]];
-  let maxIndex = [-1];
-  while (current.length > 0) {
-    const next = [];
-    const nextMaxIndex = [];
-    for (let i = 0; i < current.length; i++) {
-      for (let j = maxIndex[i] + 1; j < arr.length; j++) {
-        const subset = [...current[i], arr[j]];
-        result.push(subset);
-        if (j < arr.length - 1) {
-          next.push(subset);
-          nextMaxIndex.push(j);
-        }
-      }
-    }
-    current = next;
-    maxIndex = nextMaxIndex;
-  }
-  return result;
-}
-function contains(setData, element) {
-  let left = 0;
-  let right = setData.length - 1;
-  while (left <= right) {
-    const mid = Math.floor((left + right) / 2);
-    const cmp = compare(setData[mid], element);
-    if (cmp === 0) {
-      return true;
-    } else if (cmp < 0) {
-      left = mid + 1;
-    } else {
-      right = mid - 1;
-    }
-  }
-  return false;
-}
-function isSubsetOrEq(a, b) {
-  let i = 0, j = 0;
-  while (i < a.length && j < b.length) {
-    const cmp = compare(a[i], b[j]);
-    if (cmp === 0) {
-      i++;
-      j++;
-    } else if (cmp > 0) {
-      j++;
-    } else {
-      return false;
-    }
-  }
-  return i === a.length;
-}
-function reduce(target) {
-  const result = [];
-  for (const element of target) {
-    result.push(...element);
-  }
-  return set(result);
-}
-function setUnion(set1, set2) {
-  const result = [];
-  let i = 0, j = 0;
-  while (i < set1.length && j < set2.length) {
-    const cmp = compare(set1[i], set2[j]);
-    if (cmp < 0) {
-      result.push(set1[i]);
-      i++;
-    } else if (cmp > 0) {
-      result.push(set2[j]);
-      j++;
-    } else {
-      result.push(set1[i]);
-      i++;
-      j++;
-    }
-  }
-  while (i < set1.length) {
-    result.push(set1[i]);
-    i++;
-  }
-  while (j < set2.length) {
-    result.push(set2[j]);
-    j++;
-  }
-  return result;
-}
-function setIntersection(set1, set2) {
-  const result = [];
-  for (let i = 0, j = 0; i < set1.length && j < set2.length; ) {
-    const cmp = compare(set1[i], set2[j]);
-    if (cmp < 0) {
-      i++;
-    } else if (cmp > 0) {
-      j++;
-    } else {
-      result.push(set1[i]);
-      i++;
-      j++;
-    }
-  }
-  return result;
-}
-function setDiff(set1, set2) {
-  const result = [];
-  let i = 0, j = 0;
-  while (i < set1.length && j < set2.length) {
-    const cmp = compare(set1[i], set2[j]);
-    if (cmp < 0) {
-      result.push(set1[i]);
-      i++;
-    } else if (cmp > 0) {
-      j++;
-    } else {
-      i++;
-      j++;
-    }
-  }
-  while (i < set1.length) {
-    result.push(set1[i]);
-    i++;
-  }
-  return result;
-}
-function setSymDiff(set1, set2) {
-  const result = [];
-  let i = 0, j = 0;
-  while (i < set1.length && j < set2.length) {
-    const cmp = compare(set1[i], set2[j]);
-    if (cmp < 0) {
-      result.push(set1[i]);
-      i++;
-    } else if (cmp > 0) {
-      result.push(set2[j]);
-      j++;
-    } else {
-      i++;
-      j++;
-    }
-  }
-  while (i < set1.length) {
-    result.push(set1[i]);
-    i++;
-  }
-  while (j < set2.length) {
-    result.push(set2[j]);
-    j++;
-  }
-  return result;
-}
-function projection(target, indices) {
-  const projectedElements = target.map((element) => {
-    const newComponents = indices.map((idx) => element[idx]);
-    return indices.length === 1 ? newComponents[0] : tuple(newComponents);
-  });
-  return set(projectedElements);
-}
-function printValue(data) {
-  if (!Array.isArray(data)) {
-    return String(data);
-  }
-  const len = data.length;
-  if (data.length === 0) {
-    return "{}";
-  }
-  const isTuple = data[0] === TUPLE_ID;
-  const start = isTuple ? 1 : 0;
-  let result = isTuple ? "(" : "{";
-  for (let i = start; i < len; i++) {
-    if (i > start) result += ", ";
-    result += printValue(data[i]);
-  }
-  result += isTuple ? ")" : "}";
-  return result;
-}
-function valueStub(value) {
-  if (value == null) {
-    return "";
-  }
-  const str = printValue(value);
-  return generateStub(str);
-}
-function isSetValue(data) {
-  return Array.isArray(data) && (data.length === 0 || data[0] !== TUPLE_ID);
-}
-function isTupleValue(data) {
-  return Array.isArray(data) && data.length > 1 && data[0] === TUPLE_ID;
-}
-function normalizeValue(data) {
-  if (!Array.isArray(data) || data.length === 0) {
-    return;
-  }
-  if (data[0] === TUPLE_ID) {
-    for (let i2 = 1; i2 < data.length; i2++) {
-      normalizeValue(data[i2]);
-    }
-    return;
-  }
-  for (const item of data) {
-    normalizeValue(item);
-  }
-  data.sort((a, b) => compare(a, b));
-  let i = 1;
-  while (i < data.length) {
-    if (compare(data[i - 1], data[i]) === 0) {
-      data.splice(i, 1);
-    } else {
-      i++;
-    }
-  }
-}
-function validateValue(value, type, basics) {
-  switch (type.typeID) {
-    case TypeID.integer:
-      return typeof value === "number";
-    case TypeID.logic: {
-      if (typeof value !== "number") {
-        return false;
-      }
-      return value === VALUE_TRUE || value === VALUE_FALSE;
-    }
-    case TypeID.basic: {
-      if (typeof value !== "number") {
-        return false;
-      }
-      const domain = basics.get(type.baseID);
-      return !!domain && Array.isArray(domain) && domain.includes(value);
-    }
-    case TypeID.tuple: {
-      if (!Array.isArray(value) || value.length !== type.factors.length + 1 || value[0] !== TUPLE_ID) {
-        return false;
-      }
-      for (let i = 0; i < type.factors.length; i++) {
-        if (!validateValue(value[i + 1], type.factors[i], basics)) {
-          return false;
-        }
-      }
-      return true;
-    }
-    case TypeID.collection: {
-      if (!isSetValue(value)) {
-        return false;
-      }
-      for (const item of value) {
-        if (!validateValue(item, type.base, basics)) {
-          return false;
-        }
-      }
-      return true;
-    }
-    case TypeID.anyTypification:
-    case TypeID.predicate:
-    case TypeID.function:
-      return false;
-  }
-}
-function convertPathToType(path, type) {
-  const result = [];
-  if (path.length === 0) {
-    return result;
-  }
-  let curType = type;
-  let index = 0;
-  while (index < path.length) {
-    switch (curType.typeID) {
-      case TypeID.collection: {
-        result.push(0);
-        curType = curType.base;
-        index++;
-        break;
-      }
-      case TypeID.tuple: {
-        const tupleIdx = path[index];
-        if (typeof tupleIdx !== "number" || tupleIdx < 1 || tupleIdx > curType.factors.length) {
-          return null;
-        }
-        result.push(tupleIdx);
-        curType = curType.factors[tupleIdx - 1];
-        index++;
-        break;
-      }
-      case TypeID.basic:
-      case TypeID.integer:
-      case TypeID.anyTypification:
-        return null;
-    }
-  }
-  return result;
-}
-function extractValue(target, path) {
-  let current = target;
-  let i = 0;
-  while (i < path.length) {
-    if (!Array.isArray(current) || current.length <= path[i]) {
-      return null;
-    }
-    current = current[path[i]];
-    i++;
-  }
-  return current;
-}
-function makeDefaultValue(type) {
-  switch (type.typeID) {
-    case TypeID.anyTypification:
-    case TypeID.integer:
-    case TypeID.basic:
-      return INVALID_ELEMENT;
-    case TypeID.collection:
-      return [];
-    case TypeID.tuple:
-      return tuple(type.factors.map((item) => makeDefaultValue(item)));
-  }
-}
-function setNestedValue(target, path, newVal) {
-  if (path.length === 0) {
-    return newVal;
-  }
-  const [head, ...rest] = path;
-  const arr = Array.isArray(target) ? [...target] : [];
-  arr[head] = setNestedValue(arr[head], makeValuePath(rest), newVal);
-  return arr;
-}
-function testInvalid(value) {
-  const stack = [value];
-  while (stack.length > 0) {
-    const current = stack.pop();
-    if (current === INVALID_ELEMENT) {
-      return true;
-    }
-    if (Array.isArray(current)) {
-      for (const element of current) {
-        stack.push(element);
-      }
-    }
-  }
-  return false;
-}
-export {
-  boolean,
-  cartesianProduct,
-  contains,
-  convertPathToType,
-  extractValue,
-  isSetValue,
-  isSubsetOrEq,
-  isTupleValue,
-  makeDefaultValue,
-  normalizeValue,
-  printValue,
-  projection,
-  reduce,
-  setDiff,
-  setIntersection,
-  setNestedValue,
-  setSymDiff,
-  setUnion,
-  testInvalid,
-  validateValue,
-  valueStub
-};
-//# sourceMappingURL=value-api.js.map
+import { A as testInvalid, C as projection, D as setNestedValue, E as setIntersection, M as valueStub, O as setSymDiff, S as printValue, T as setDiff, _ as isSetValue, b as makeDefaultValue, f as boolean, g as extractValue, h as convertPathToType, j as validateValue, k as setUnion, m as contains, p as cartesianProduct, v as isSubsetOrEq, w as reduce, x as normalizeValue, y as isTupleValue } from "../../value-B8UtCqaK.js";
+export { boolean, cartesianProduct, contains, convertPathToType, extractValue, isSetValue, isSubsetOrEq, isTupleValue, makeDefaultValue, normalizeValue, printValue, projection, reduce, setDiff, setIntersection, setNestedValue, setSymDiff, setUnion, testInvalid, validateValue, valueStub };

package/dist/rslang/eval/value.d.ts

@@ -1,36 +1,2 @@
-import { Branded } from '../../shared/branded.js';
-
-/**
- * Module: Structured data for RSLang expression evaluation.
- */
-
-/** Tuple ID for array distinction. */
-declare const TUPLE_ID = -111;
-/** Invalid value for structured data. */
-declare const INVALID_ELEMENT = -1;
-/** Boolean values: true. */
-declare const VALUE_TRUE = 1;
-/** Boolean values: false. */
-declare const VALUE_FALSE = 0;
-/** Cardinality threshold for "infinite" sets (e.g. Z). */
-declare const SET_INFINITY = 10000000;
-/** Cardinality threshold for Boolean power set. */
-declare const BOOL_INFINITY = 18;
-/** Expression evaluation result: structured data. */
-type Value = number | Value[];
-/** Values context. */
-type ValueContext = Map<string, Value>;
-/** Value extraction path. */
-type ValuePath = Branded<number[], 'ValuePath'>;
-/** Creates value path. */
-declare function makeValuePath(path: number[]): ValuePath;
-/** Empty set ∅. */
-declare const EmptySetV: never[];
-/** Compare two structured data without recursive calls. */
-declare function compare(v1: Value, v2: Value): number;
-/** Tuple from components. */
-declare function tuple(components: Value[]): Value;
-/** Set from elements (unique). Value[] - materialized. */
-declare function set(elements: Value[]): Value[];
-
-export { BOOL_INFINITY, EmptySetV, INVALID_ELEMENT, SET_INFINITY, TUPLE_ID, VALUE_FALSE, VALUE_TRUE, type Value, type ValueContext, type ValuePath, compare, makeValuePath, set, tuple };
+import { a as TUPLE_ID, c as Value, d as compare, f as makeValuePath, i as SET_INFINITY, l as ValueContext, m as tuple, n as EmptySetV, o as VALUE_FALSE, p as set, r as INVALID_ELEMENT, s as VALUE_TRUE, t as BOOL_INFINITY, u as ValuePath } from "../../value-CTjX6825.js";
+export { BOOL_INFINITY, EmptySetV, INVALID_ELEMENT, SET_INFINITY, TUPLE_ID, VALUE_FALSE, VALUE_TRUE, Value, ValueContext, ValuePath, compare, makeValuePath, set, tuple };

package/dist/rslang/eval/value.js

@@ -1,118 +1,2 @@
-// src/rslang/semantic/typification.ts
-var TypeID = {
-  anyTypification: 1,
-  integer: 2,
-  basic: 3,
-  tuple: 4,
-  collection: 5,
-  logic: 6,
-  function: 7,
-  predicate: 8
-};
-var LogicT = { typeID: TypeID.logic };
-var IntegerT = {
-  typeID: TypeID.integer,
-  isOrdered: true,
-  isArithmetic: true,
-  isIntegerCompatible: true
-};
-var AnyTypificationT = { typeID: TypeID.anyTypification };
-var EmptySetT = bool(AnyTypificationT);
-function bool(base) {
-  return { typeID: TypeID.collection, base };
-}
-
-// src/rslang/eval/value-api.ts
-function printValue(data) {
-  if (!Array.isArray(data)) {
-    return String(data);
-  }
-  const len = data.length;
-  if (data.length === 0) {
-    return "{}";
-  }
-  const isTuple = data[0] === TUPLE_ID;
-  const start = isTuple ? 1 : 0;
-  let result = isTuple ? "(" : "{";
-  for (let i = start; i < len; i++) {
-    if (i > start) result += ", ";
-    result += printValue(data[i]);
-  }
-  result += isTuple ? ")" : "}";
-  return result;
-}
-
-// src/rslang/eval/value.ts
-var TUPLE_ID = -111;
-var INVALID_ELEMENT = -1;
-var VALUE_TRUE = 1;
-var VALUE_FALSE = 0;
-var SET_INFINITY = 1e7;
-var BOOL_INFINITY = 18;
-function makeValuePath(path) {
-  return path;
-}
-var EmptySetV = [];
-function compare(v1, v2) {
-  const stack1 = [v1];
-  const stack2 = [v2];
-  while (stack1.length > 0 && stack2.length > 0) {
-    const el1 = stack1.pop();
-    const el2 = stack2.pop();
-    if (el1 === el2) {
-      continue;
-    }
-    const type1 = typeof el1;
-    const type2 = typeof el2;
-    if (type1 === "number" && type2 === "number") {
-      const numDiff = el1 - el2;
-      if (numDiff !== 0) return numDiff;
-      continue;
-    }
-    const isArray1 = Array.isArray(el1);
-    const isArray2 = Array.isArray(el2);
-    if (!isArray1 || !isArray2) {
-      throw new Error(`Cannot compare different types ${printValue(el1)} and ${printValue(el2)}`);
-    }
-    const arr1 = el1;
-    const arr2 = el2;
-    const len1 = arr1.length;
-    const len2 = arr2.length;
-    if (len1 !== len2) {
-      return len1 - len2;
-    }
-    for (let i = len1 - 1; i >= 0; i--) {
-      stack1.push(arr1[i]);
-      stack2.push(arr2[i]);
-    }
-  }
-  return 0;
-}
-function tuple(components) {
-  return [TUPLE_ID, ...components];
-}
-function set(elements) {
-  const sorted = [...elements].sort(compare);
-  for (let i = 1; i < sorted.length; ) {
-    if (compare(sorted[i - 1], sorted[i]) === 0) {
-      sorted.splice(i, 1);
-    } else {
-      i++;
-    }
-  }
-  return sorted;
-}
-export {
-  BOOL_INFINITY,
-  EmptySetV,
-  INVALID_ELEMENT,
-  SET_INFINITY,
-  TUPLE_ID,
-  VALUE_FALSE,
-  VALUE_TRUE,
-  compare,
-  makeValuePath,
-  set,
-  tuple
-};
-//# sourceMappingURL=value.js.map
+import { a as TUPLE_ID, c as compare, d as tuple, i as SET_INFINITY, l as makeValuePath, n as EmptySetV, o as VALUE_FALSE, r as INVALID_ELEMENT, s as VALUE_TRUE, t as BOOL_INFINITY, u as set } from "../../value-B8UtCqaK.js";
+export { BOOL_INFINITY, EmptySetV, INVALID_ELEMENT, SET_INFINITY, TUPLE_ID, VALUE_FALSE, VALUE_TRUE, compare, makeValuePath, set, tuple };

package/dist/rslang/index.d.ts

@@ -1,17 +1,14 @@
-export { readErrorAnnotation, readTypeAnnotation } from './ast-annotations.js';
-export { RSErrorCode, RSErrorDescription } from './error.js';
-export { CalculatorEvaluateOptions, CalculatorResult, RSCalculator } from './eval/calculator.js';
-export { Value, ValuePath, makeValuePath } from './eval/value.js';
-export { printValue } from './eval/value-api.js';
-export { parser as rslangParser } from './parser/parser.js';
-export { TokenID } from './parser/token.js';
-export { AnalysisBase, AnalysisFast, AnalysisFull, RSLangAnalyzer } from './semantic/analyzer.js';
-export { ArgumentsType } from './semantic/arguments-extractor.js';
-export { AnyTypificationT, EmptySetT, ExpressionType, LogicT, TypeClass, TypeID, TypePath, Typification, makeTypePath } from './semantic/typification.js';
-export { applyAsciiTypeSubstitutions, parseTypeText } from './semantic/typification-parser.js';
-export { ValueClass } from './semantic/value-class.js';
-export { TypificationGraph, TypificationNodeData } from './typification-graph.js';
-import '../parsing/ast.js';
-import '@lezer/common';
-import '../shared/branded.js';
-import '@lezer/lr';
+import { O as makeTypePath, b as Typification, d as EmptySetT, f as ExpressionType, g as TypeClass, m as LogicT, t as AnyTypificationT, v as TypeID, y as TypePath } from "../typification-Dk-fisgO.js";
+import { i as RSErrorDescription, r as RSErrorCode } from "../error-E1LVq_3w.js";
+import { i as readTypeAnnotation, r as readErrorAnnotation } from "../ast-annotations-BiMjkKvz.js";
+import { c as Value, f as makeValuePath, u as ValuePath } from "../value-CTjX6825.js";
+import { n as CalculatorResult, r as RSCalculator, t as CalculatorEvaluateOptions } from "../calculator-C9W2jkSx.js";
+import { d as printValue } from "../value-api-Bw-SgaYY.js";
+import { t as parser } from "../parser-Bwd8LxJ1.js";
+import { t as TokenID } from "../token-DeXAmzwr.js";
+import { t as ValueClass } from "../value-class-CNI-lqXJ.js";
+import { a as RSLangAnalyzer, n as AnalysisFast, r as AnalysisFull, t as AnalysisBase } from "../analyzer-DlSq3Y3r.js";
+import { n as ArgumentsType } from "../arguments-extractor-1acwjQNc.js";
+import { n as applyAsciiTypeSubstitutions, r as parseTypeText } from "../typification-parser-BBVx1RxP.js";
+import { n as TypificationNodeData, t as TypificationGraph } from "../typification-graph-6HcZ-rKH.js";
+export { type AnalysisBase, type AnalysisFast, type AnalysisFull, AnyTypificationT, type ArgumentsType, type CalculatorEvaluateOptions, type CalculatorResult, EmptySetT, type ExpressionType, LogicT, RSCalculator, RSErrorCode, type RSErrorDescription, RSLangAnalyzer, TokenID, TypeClass, TypeID, type TypePath, type Typification, TypificationGraph, type TypificationNodeData, type Value, ValueClass, type ValuePath, applyAsciiTypeSubstitutions, makeTypePath, makeValuePath, parseTypeText, printValue, readErrorAnnotation, readTypeAnnotation, parser as rslangParser };