@kontur.candy/tools 2.210.1-cgroupv2.0 → 2.210.1-cgroupv2.1

package/distr/Common/ModelPath/ModelPath.js

@@ -0,0 +1,476 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.PathTokens = exports.ModelPathImpl = void 0;
+exports.convertToAbsoluteModelPath = convertToAbsoluteModelPath;
+exports.convertToLegacyPath = convertToLegacyPath;
+exports.convertToRelativeModelPath = convertToRelativeModelPath;
+exports.createAbsolute = createAbsolute;
+exports.createAbsoluteFromMask = createAbsoluteFromMask;
+exports.createAbsoluteFromTokens = createAbsoluteFromTokens;
+exports.createAbsoluteResolvedFromTokens = createAbsoluteResolvedFromTokens;
+exports.createFromMask = createFromMask;
+exports.createModelPath = createModelPath;
+exports.createRelativeFromMask = createRelativeFromMask;
+exports.createRelativeFromTokens = createRelativeFromTokens;
+exports.createRelativeResolvedModelPath = createRelativeResolvedModelPath;
+exports.emptyAbsoluteModelPath = emptyAbsoluteModelPath;
+exports.emptyModelPath = emptyModelPath;
+exports.isModelPath = isModelPath;
+exports.joinModelPaths = joinModelPaths;
+var _IterableUtils = require("../IterableUtils");
+var _TypingUtils = require("../TypingUtils");
+var _EachCurrentCollision = require("./EachCurrentCollision");
+var _ModelPathBuilder = require("./ModelPathBuilder");
+var _PathMatcher = require("./PathMatcher");
+const EachSymbol = Symbol.for("__EACH__");
+const CurrentSymbol = Symbol.for("__CURRENT__");
+class PathTokens {
+  static isMultiToken(part) {
+    return part === PathTokens.each || part === PathTokens.current;
+  }
+  static isSimpleToken(part) {
+    return typeof part === "string";
+  }
+  static isInstanceToken(part) {
+    return typeof part === "string" && /^\d+$/i.test(part);
+  }
+  static isInstanceTokenOrInstancesSpec(part) {
+    return typeof part === "string" && (/^\d+$/i.test(part) || /^\[(\d+\,?)+\]$/i.test(part));
+  }
+}
+exports.PathTokens = PathTokens;
+PathTokens.each = EachSymbol;
+PathTokens.current = CurrentSymbol;
+function isModelPath(path) {
+  return typeof path !== "string" && path instanceof ModelPathImpl;
+}
+function convertToLegacyPath(path) {
+  return isModelPath(path) ? path.toLegacyPath() : path;
+}
+function convertToAbsoluteModelPath(path) {
+  return isModelPath(path) ? path : createAbsoluteFromMask(path, PathTokens.each);
+}
+function convertToRelativeModelPath(path) {
+  return isModelPath(path) ? path : createRelativeFromMask(path, PathTokens.each);
+}
+function emptyModelPath() {
+  return new ModelPathImpl([], false);
+}
+function emptyAbsoluteModelPath() {
+  return new ModelPathImpl([], true);
+}
+function createModelPath(path, absolute) {
+  const partPartStrings = path.split("/");
+  ensurePlainPathPartsDoesNotContainMultiplicity(partPartStrings);
+  if (absolute === "auto") {
+    if (path.startsWith("/")) {
+      return new ModelPathImpl(partPartStrings.slice(1), true);
+    } else {
+      return new ModelPathImpl(partPartStrings, false);
+    }
+  }
+  if (absolute && path.startsWith("/")) {
+    return new ModelPathImpl(partPartStrings.slice(1), true);
+  }
+  return new ModelPathImpl(partPartStrings, absolute);
+}
+function createFromMask(path, absolute, multiplicitySymbol) {
+  const partPartStrings = path.split("/").map(x => x === "*" ? multiplicitySymbol : x);
+  if (absolute === "auto") {
+    if (path.startsWith("/")) {
+      return new ModelPathImpl(partPartStrings.slice(1), true);
+    } else {
+      return new ModelPathImpl(partPartStrings, false);
+    }
+  }
+  if (absolute && path.startsWith("/")) {
+    return new ModelPathImpl(partPartStrings.slice(1), true);
+  }
+  return new ModelPathImpl(partPartStrings, absolute);
+}
+function createAbsoluteFromMask(path, multiplicitySymbol) {
+  const partPartStrings = path.split("/").map(x => x === "*" ? multiplicitySymbol : x);
+  if (path.startsWith("/")) {
+    return new ModelPathImpl(partPartStrings.slice(1), true);
+  }
+  return new ModelPathImpl(partPartStrings, true);
+}
+function createRelativeFromMask(path, multiplicitySymbol) {
+  const partPartStrings = path.split("/").map(x => x === "*" ? multiplicitySymbol : x);
+  return new ModelPathImpl(partPartStrings, false);
+}
+function ensurePlainPathPartsDoesNotContainMultiplicity(parts) {
+  if (parts.some(x => x === "*")) {
+    throw new Error("Path must not contain * symbol");
+  }
+}
+function createAbsolute(path) {
+  const partPartStrings = path.split("/");
+  ensurePlainPathPartsDoesNotContainMultiplicity(partPartStrings);
+  if (path.startsWith("/")) {
+    return new ModelPathImpl(partPartStrings.slice(1), true);
+  }
+  return new ModelPathImpl(partPartStrings, true);
+}
+function createRelativeResolvedModelPath(path) {
+  const partPartStrings = path.split("/");
+  ensurePlainPathPartsDoesNotContainMultiplicity(partPartStrings);
+  return new ModelPathImpl(partPartStrings, false);
+}
+function createAbsoluteFromTokens(tokens) {
+  return new ModelPathImpl(tokens, true);
+}
+function createAbsoluteResolvedFromTokens(tokens) {
+  ensurePlainPathPartsDoesNotContainMultiplicity(tokens);
+  return new ModelPathImpl(tokens, true);
+}
+function createRelativeFromTokens(tokens) {
+  return new ModelPathImpl(tokens, false);
+}
+function joinModelPaths(...parts) {
+  let absolute = false;
+  let resultParts = [];
+  for (const joinItem of parts) {
+    if (typeof joinItem === "string") {
+      resultParts.push(joinItem);
+    } else if (isModelPath(joinItem)) {
+      if (joinItem.isAbsolute()) {
+        absolute = true;
+        resultParts = [...joinItem.getPathPartsAsArray()];
+      } else {
+        resultParts.push(...joinItem.getPathPartsAsArray());
+      }
+    } else if (Array.isArray(joinItem)) {
+      resultParts.push(...joinItem);
+    } else if (PathTokens.isMultiToken(joinItem)) {
+      resultParts.push(joinItem);
+    }
+  }
+  return new ModelPathImpl(resultParts, absolute);
+}
+function isAllTokensResolved(tokens) {
+  // Я что-то немогу сообразить как тут всё строго написать...
+  // @ts-expect-error
+  return tokens.every(PathTokens.isSimpleToken);
+}
+class ModelPathImpl {
+  constructor(pathParts, absolute) {
+    this.tokens = void 0;
+    this.absolute = void 0;
+    this.legacyPath = void 0;
+    this.cachedHash = void 0;
+    this.tokens = pathParts.filter(x => x !== "");
+    this.absolute = absolute;
+  }
+  get resolved() {
+    return isAllTokensResolved(this.tokens);
+  }
+  getPathParts() {
+    return this.tokens;
+  }
+  getPathPartsAsArray() {
+    return this.tokens;
+  }
+  *getSimpleTokensStrict() {
+    for (const token of this.tokens) {
+      if (!PathTokens.isSimpleToken(token)) {
+        throw new Error("Path must not contain spec tokens");
+      }
+      yield token;
+    }
+  }
+  getSimpleTokensAsArrayStrict() {
+    for (const token of this.tokens) {
+      if (!PathTokens.isSimpleToken(token)) {
+        throw new Error("Path must not contain spec tokens");
+      }
+    }
+    // Проверка выше гараентирует что будут только SimplePathToken.
+    // Все map и filter убраны для производительности
+    // @ts-ignore
+    return this.tokens;
+  }
+  joinWith(...path) {
+    return joinModelPaths(this, ...path);
+  }
+  isResolved() {
+    return isAllTokensResolved(this.tokens);
+  }
+  resolveAll(instance) {
+    const tokens = this.tokens.map(token => {
+      if (PathTokens.isSimpleToken(token)) {
+        return token;
+      } else {
+        return instance;
+      }
+    });
+    return new ModelPathImpl(tokens, this.absolute);
+  }
+  isContainIteration() {
+    return this.tokens.some(x => x === PathTokens.each);
+  }
+  isContainCurrentIteration() {
+    return this.tokens.some(x => x === PathTokens.current);
+  }
+  isContainCurrentOrEachIteration() {
+    return this.tokens.some(x => x === PathTokens.current || x === PathTokens.each);
+  }
+  getLastListPath() {
+    if (!this.isContainIteration()) {
+      throw new Error("Path must contain iteration");
+    }
+
+    // Проверка выше гарантирует, что будет PathTokens.each
+    // @ts-ignore
+    const lastIterationIndex = this.tokens.lastIndexOf(PathTokens.each);
+    return this.tokens.slice(0, lastIterationIndex);
+  }
+  isEndsWithIteration() {
+    const lastItem = _IterableUtils.IterUtils.last(this.tokens);
+    return lastItem == PathTokens.each;
+  }
+  isEndsWithCurrentIteration() {
+    const lastItem = _IterableUtils.IterUtils.last(this.tokens);
+    return lastItem == PathTokens.current;
+  }
+  isAbsolute() {
+    return this.absolute;
+  }
+  toString() {
+    if (this.tokens.length === 0) {
+      return "";
+    }
+    return (this.absolute ? "/" : "") + this.tokens.map(x => this.pathPartToString(x)).join("/");
+  }
+  toLegacyPath() {
+    var _this$legacyPath;
+    return (_this$legacyPath = this.legacyPath) !== null && _this$legacyPath !== void 0 ? _this$legacyPath : this.legacyPath = this.tokens.map(x => this.pathPartToString(x)).join("/");
+  }
+  isEquals(modelPath, eachCurrentCollision = _EachCurrentCollision.EachCurrentCollision.AreSame) {
+    if (eachCurrentCollision === _EachCurrentCollision.EachCurrentCollision.AreSame) {
+      return this.toLegacyPath() === modelPath.toLegacyPath();
+    } else {
+      return this.isAbsolute() === modelPath.isAbsolute() && Iterator.from(_IterableUtils.IterUtils.zip(this.getPathParts(), modelPath.getPathParts())).every(([t1, t2]) => t1 === t2);
+    }
+  }
+
+  /**
+   * Всегда целое положительное беззнаковое 32-битное число
+   */
+  getHash(eachCurrentCollision = _EachCurrentCollision.EachCurrentCollision.AreSame) {
+    if (this.cachedHash == undefined) {
+      let hash = 5381;
+      for (const token of (0, _IterableUtils.reverseArray)(this.tokens)) {
+        let currentStr;
+        if (PathTokens.isSimpleToken(token)) {
+          currentStr = token;
+        } else {
+          if (eachCurrentCollision === _EachCurrentCollision.EachCurrentCollision.AreDifferent) {
+            currentStr = token === PathTokens.each ? "*" : "!";
+          } else {
+            currentStr = "*";
+          }
+        }
+        let stringIndex = currentStr.length;
+        while (stringIndex) {
+          // tslint:disable-next-line:no-bitwise
+          hash = hash * 33 ^ currentStr.charCodeAt(--stringIndex);
+        }
+      }
+
+      /*
+          tslint:disable-next-line:no-bitwise
+          JavaScript does bitwise operations (like XOR, above) on 32-bit signed
+          integers. Since we want the results to be always positive, convert the
+          signed int to an unsigned by doing an unsigned bitshift.
+      */
+      this.cachedHash = hash >>> 0;
+    }
+    return this.cachedHash;
+  }
+  isIncludes(modelPath) {
+    const targetTokens = modelPath.getPathPartsAsArray();
+    if (this.tokens.length !== targetTokens.length) {
+      return false;
+    }
+    for (let i = 0; i < this.tokens.length; i++) {
+      const leftPart = this.tokens[i];
+      const rightPart = targetTokens[i];
+      if (typeof leftPart === "string") {
+        if (typeof rightPart === "string") {
+          if (leftPart !== rightPart) {
+            return false;
+          }
+          continue;
+        } else {
+          return false;
+        }
+      } else if (leftPart === PathTokens.current || leftPart === PathTokens.each) {
+        if (typeof rightPart === "string") {
+          if (!isFinite(Number(rightPart))) {
+            return false;
+          }
+          continue;
+        } else {
+          if (rightPart !== PathTokens.current && rightPart !== PathTokens.each) {
+            return false;
+          }
+          continue;
+        }
+      }
+    }
+    return true;
+  }
+  getIterationRank(eachCurrentCollision = _EachCurrentCollision.EachCurrentCollision.AreDifferent) {
+    return (0, _IterableUtils.count)(Iterator.from(this.tokens).filter(x => eachCurrentCollision == _EachCurrentCollision.EachCurrentCollision.AreDifferent ? x === PathTokens.each : PathTokens.isMultiToken(x)));
+  }
+  isEmpty() {
+    return this.tokens.length === 0;
+  }
+  matchFor(modelPath) {
+    if (!this.isAbsolute()) {
+      throw new Error(`Cannot match non absolute path '${this.toString()}'`);
+    }
+    if (!modelPath.isAbsolute()) {
+      throw new Error(`Cannot match non absolute path '${modelPath.toString()}'`);
+    }
+    return _PathMatcher.PathMatcher.match(this.tokens, modelPath.getPathPartsAsArray());
+  }
+  startsWith(modelPath) {
+    const thisParts = this.getPathPartsAsArray();
+    const otherParts = modelPath.getPathPartsAsArray();
+    return otherParts.every((value, index) => value === thisParts[index]);
+  }
+  endsWith(modelPath) {
+    const thisParts = this.getPathPartsAsArray().slice().reverse();
+    const otherParts = modelPath.getPathPartsAsArray().slice().reverse();
+    return otherParts.every((value, index) => value === thisParts[index]);
+  }
+  *splitByMultiplicity() {
+    let lastSimpleParts = new _ModelPathBuilder.ModelPathBuilder(this.isAbsolute());
+    for (const token of this.tokens) {
+      if (PathTokens.isSimpleToken(token)) {
+        lastSimpleParts.append(token);
+      } else {
+        if (!lastSimpleParts.empty) {
+          yield lastSimpleParts.toResolvedPath();
+          lastSimpleParts = new _ModelPathBuilder.ModelPathBuilder(false);
+        }
+        yield token;
+      }
+    }
+    if (!lastSimpleParts.empty) {
+      yield lastSimpleParts.toResolvedPath();
+    }
+  }
+  normalize() {
+    const resultTokens = [];
+    for (const pathPart of this.tokens) {
+      if (pathPart === "..") {
+        if (!resultTokens.pop()) {
+          if (this.isAbsolute()) {
+            throw new Error(`Path is invalid '${this.toString()}'`);
+          } else {
+            resultTokens.push("..");
+          }
+        }
+        continue;
+      }
+      if (pathPart === ".") {
+        continue;
+      }
+      resultTokens.push(pathPart);
+    }
+    return new ModelPathImpl(resultTokens, this.absolute);
+  }
+
+  /**
+   * @summary Спецификаторы множественности Each заменяет на Current
+   */
+  toCurrentIteration() {
+    if (this.isResolved()) {
+      return this;
+    } else {
+      // NOTE Тут не получается наложить дискриминатор
+      // @ts-expect-error
+      const pathParts = this.tokens.map(x => x === PathTokens.each ? PathTokens.current : x);
+      return new ModelPathImpl(pathParts, this.absolute);
+    }
+  }
+  toEachIteration() {
+    if (this.isResolved()) {
+      return this;
+    } else {
+      // NOTE Тут не получается наложить дискриминатор
+      // @ts-expect-error
+      const pathParts = this.tokens.map(x => x === PathTokens.current ? PathTokens.each : x);
+      return new ModelPathImpl(pathParts, this.absolute);
+    }
+  }
+  toAbsolute() {
+    if (!this.absolute) {
+      throw new Error(`Path '${this.toLegacyPath()} is not absolute'`);
+    }
+    return new ModelPathImpl(this.tokens, true);
+  }
+  *getAllParentPaths() {
+    const result = new _ModelPathBuilder.ModelPathBuilder(this.isAbsolute());
+    for (const token of _IterableUtils.IterUtils.skipLast(this.getPathParts(), 1)) {
+      result.append(token);
+      yield result.toPath();
+    }
+  }
+  trimLastStarIfLastToken() {
+    const lastItem = _IterableUtils.IterUtils.last(this.tokens);
+    if (lastItem != undefined && PathTokens.isMultiToken(lastItem)) {
+      return new ModelPathImpl(this.tokens.slice(0, -1), this.absolute);
+    }
+    return this;
+  }
+  getParentPath() {
+    const result = new _ModelPathBuilder.ModelPathBuilder(this.absolute);
+    for (const token of _IterableUtils.IterUtils.skipLast(this.getPathParts(), 1)) {
+      result.append(token);
+    }
+    // Тут получается так, что по другому никак
+    // @ts-expect-error
+    return result.toPath();
+  }
+  applyInstancesDirty(instances, fillWithMultiplicityIfHasNoInstance) {
+    if (this.isResolved() || instances.length === 0) {
+      return this;
+    }
+    let instanceCounter = 0;
+    const result = new _ModelPathBuilder.ModelPathBuilder(true);
+    for (const token of this.getPathParts()) {
+      if (PathTokens.isMultiToken(token) && instanceCounter < instances.length) {
+        var _instances$instanceCo;
+        const instanceOrEach = (_instances$instanceCo = instances[instanceCounter]) !== null && _instances$instanceCo !== void 0 ? _instances$instanceCo : fillWithMultiplicityIfHasNoInstance == true ? PathTokens.each : (0, _TypingUtils.reject)();
+        result.append(instanceOrEach);
+        instanceCounter++;
+      } else {
+        result.append(token);
+      }
+    }
+    // Тут получается так, что по другому никак
+    // @ts-expect-error
+    return result.toPath();
+  }
+  pathPartToString(pathPart) {
+    if (typeof pathPart === "string") {
+      return pathPart;
+    }
+    if (pathPart === PathTokens.each) {
+      return "*";
+    }
+    if (pathPart === PathTokens.current) {
+      return "*";
+    }
+    throw new Error(`Unknown path part specified: ${(0, _TypingUtils.ensureAndGetString)(pathPart)}`);
+  }
+}
+exports.ModelPathImpl = ModelPathImpl;
+//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"names":["_IterableUtils","require","_TypingUtils","_EachCurrentCollision","_ModelPathBuilder","_PathMatcher","EachSymbol","Symbol","for","CurrentSymbol","PathTokens","isMultiToken","part","each","current","isSimpleToken","isInstanceToken","test","isInstanceTokenOrInstancesSpec","exports","isModelPath","path","ModelPathImpl","convertToLegacyPath","toLegacyPath","convertToAbsoluteModelPath","createAbsoluteFromMask","convertToRelativeModelPath","createRelativeFromMask","emptyModelPath","emptyAbsoluteModelPath","createModelPath","absolute","partPartStrings","split","ensurePlainPathPartsDoesNotContainMultiplicity","startsWith","slice","createFromMask","multiplicitySymbol","map","x","parts","some","Error","createAbsolute","createRelativeResolvedModelPath","createAbsoluteFromTokens","tokens","createAbsoluteResolvedFromTokens","createRelativeFromTokens","joinModelPaths","resultParts","joinItem","push","isAbsolute","getPathPartsAsArray","Array","isArray","isAllTokensResolved","every","constructor","pathParts","legacyPath","cachedHash","filter","resolved","getPathParts","getSimpleTokensStrict","token","getSimpleTokensAsArrayStrict","joinWith","isResolved","resolveAll","instance","isContainIteration","isContainCurrentIteration","isContainCurrentOrEachIteration","getLastListPath","lastIterationIndex","lastIndexOf","isEndsWithIteration","lastItem","IterUtils","last","isEndsWithCurrentIteration","toString","length","pathPartToString","join","_this$legacyPath","isEquals","modelPath","eachCurrentCollision","EachCurrentCollision","AreSame","Iterator","from","zip","t1","t2","getHash","undefined","hash","reverseArray","currentStr","AreDifferent","stringIndex","charCodeAt","isIncludes","targetTokens","i","leftPart","rightPart","isFinite","Number","getIterationRank","count","isEmpty","matchFor","PathMatcher","match","thisParts","otherParts","value","index","endsWith","reverse","splitByMultiplicity","lastSimpleParts","ModelPathBuilder","append","empty","toResolvedPath","normalize","resultTokens","pathPart","pop","toCurrentIteration","toEachIteration","toAbsolute","getAllParentPaths","result","skipLast","toPath","trimLastStarIfLastToken","getParentPath","applyInstancesDirty","instances","fillWithMultiplicityIfHasNoInstance","instanceCounter","_instances$instanceCo","instanceOrEach","reject","ensureAndGetString"],"sources":["../../../../Common/ModelPath/ModelPath.ts"],"sourcesContent":["import { BindingPath } from \"../../Engine/src/Engine/Core/CoreTypes\";\nimport { count, IterUtils, reverseArray } from \"../IterableUtils\";\nimport { ensureAndGetString, reject } from \"../TypingUtils\";\n\nimport { EachCurrentCollision } from \"./EachCurrentCollision\";\nimport { ModelPathBuilder } from \"./ModelPathBuilder\";\nimport { PathMatcher, PathMatching } from \"./PathMatcher\";\nimport { IEquatable } from \"./IEquatable\";\n\nconst EachSymbol = Symbol.for(\"__EACH__\");\nconst CurrentSymbol = Symbol.for(\"__CURRENT__\");\n\nexport class PathTokens {\n    public static each: typeof EachSymbol = EachSymbol;\n    public static current: typeof CurrentSymbol = CurrentSymbol;\n\n    public static isMultiToken(part: undefined | PathToken): part is typeof EachSymbol | typeof CurrentSymbol {\n        return part === PathTokens.each || part === PathTokens.current;\n    }\n\n    public static isSimpleToken(part: undefined | PathToken): part is string {\n        return typeof part === \"string\";\n    }\n\n    public static isInstanceToken(part: undefined | PathToken): part is string {\n        return typeof part === \"string\" && /^\\d+$/i.test(part);\n    }\n\n    public static isInstanceTokenOrInstancesSpec(part: undefined | PathToken): part is string {\n        return typeof part === \"string\" && (/^\\d+$/i.test(part) || /^\\[(\\d+\\,?)+\\]$/i.test(part));\n    }\n}\n\nexport type SimplePathToken = string;\n\nexport type PathToken = SimplePathToken | typeof EachSymbol | typeof CurrentSymbol;\n\nexport function isModelPath(path: BindingPath | ModelPath | unknown): path is ModelPath {\n    return typeof path !== \"string\" && path instanceof ModelPathImpl;\n}\n\nexport function convertToLegacyPath(path: BindingPath | ModelPath): BindingPath {\n    return isModelPath(path) ? path.toLegacyPath() : path;\n}\n\nexport function convertToAbsoluteModelPath<R extends boolean, A extends boolean>(\n    path: BindingPath | IModelPath<R, A>\n): IModelPath<R, true>;\nexport function convertToAbsoluteModelPath(path: BindingPath | AbsoluteModelPath): AbsoluteModelPath {\n    return isModelPath(path) ? path : createAbsoluteFromMask(path, PathTokens.each);\n}\n\nexport function convertToRelativeModelPath<R extends boolean, A extends boolean>(\n    path: BindingPath | IModelPath<R, A>\n): IModelPath<R, false>;\nexport function convertToRelativeModelPath(path: BindingPath | RelativeModelPath): RelativeModelPath {\n    return isModelPath(path) ? path : createRelativeFromMask(path, PathTokens.each);\n}\n\nexport function emptyModelPath(): RelativeResolvedModelPath {\n    return new ModelPathImpl<true, false>([], false);\n}\n\nexport function emptyAbsoluteModelPath(): AbsoluteResolvedModelPath {\n    return new ModelPathImpl<true, true>([], true);\n}\n\nexport function createModelPath(path: string, absolute: true): AbsoluteResolvedModelPath;\nexport function createModelPath(path: string, absolute: false): RelativeResolvedModelPath;\nexport function createModelPath(path: string, absolute: \"auto\"): ResolvedModelPath;\nexport function createModelPath(path: string, absolute: boolean | \"auto\"): ResolvedModelPath {\n    const partPartStrings = path.split(\"/\");\n    ensurePlainPathPartsDoesNotContainMultiplicity(partPartStrings);\n    if (absolute === \"auto\") {\n        if (path.startsWith(\"/\")) {\n            return new ModelPathImpl<true, true>(partPartStrings.slice(1), true);\n        } else {\n            return new ModelPathImpl<true, false>(partPartStrings, false);\n        }\n    }\n    if (absolute && path.startsWith(\"/\")) {\n        return new ModelPathImpl<true, true>(partPartStrings.slice(1), true);\n    }\n    return new ModelPathImpl<true, boolean>(partPartStrings, absolute);\n}\n\nexport function createFromMask(path: string, absolute: true, multiplicitySymbol: PathToken): AbsoluteModelPath;\nexport function createFromMask(path: string, absolute: false, multiplicitySymbol: PathToken): ResolvedModelPath;\nexport function createFromMask(path: string, absolute: \"auto\", multiplicitySymbol: PathToken): ModelPath;\nexport function createFromMask(path: string, absolute: boolean | \"auto\", multiplicitySymbol: PathToken): ModelPath {\n    const partPartStrings = path.split(\"/\").map(x => (x === \"*\" ? multiplicitySymbol : x));\n    if (absolute === \"auto\") {\n        if (path.startsWith(\"/\")) {\n            return new ModelPathImpl(partPartStrings.slice(1), true);\n        } else {\n            return new ModelPathImpl(partPartStrings, false);\n        }\n    }\n    if (absolute && path.startsWith(\"/\")) {\n        return new ModelPathImpl(partPartStrings.slice(1), true);\n    }\n    return new ModelPathImpl(partPartStrings, absolute);\n}\n\nexport function createAbsoluteFromMask(path: string, multiplicitySymbol: PathToken): AbsoluteModelPath {\n    const partPartStrings = path.split(\"/\").map(x => (x === \"*\" ? multiplicitySymbol : x));\n    if (path.startsWith(\"/\")) {\n        return new ModelPathImpl(partPartStrings.slice(1), true);\n    }\n    return new ModelPathImpl(partPartStrings, true);\n}\n\nexport function createRelativeFromMask(path: string, multiplicitySymbol: PathToken): RelativeModelPath {\n    const partPartStrings = path.split(\"/\").map(x => (x === \"*\" ? multiplicitySymbol : x));\n    return new ModelPathImpl(partPartStrings, false);\n}\n\nfunction ensurePlainPathPartsDoesNotContainMultiplicity(parts: readonly string[]): void {\n    if (parts.some(x => x === \"*\")) {\n        throw new Error(\"Path must not contain * symbol\");\n    }\n}\n\nexport function createAbsolute(path: string): AbsoluteResolvedModelPath {\n    const partPartStrings = path.split(\"/\");\n    ensurePlainPathPartsDoesNotContainMultiplicity(partPartStrings);\n    if (path.startsWith(\"/\")) {\n        return new ModelPathImpl<true, true>(partPartStrings.slice(1), true);\n    }\n    return new ModelPathImpl<true, true>(partPartStrings, true);\n}\n\nexport function createRelativeResolvedModelPath(path: string): RelativeResolvedModelPath {\n    const partPartStrings = path.split(\"/\");\n    ensurePlainPathPartsDoesNotContainMultiplicity(partPartStrings);\n    return new ModelPathImpl<true, false>(partPartStrings, false);\n}\n\nexport function createAbsoluteFromTokens(tokens: PathToken[]): AbsoluteModelPath {\n    return new ModelPathImpl<false, true>(tokens, true);\n}\n\nexport function createAbsoluteResolvedFromTokens(tokens: readonly string[]): AbsoluteResolvedModelPath {\n    ensurePlainPathPartsDoesNotContainMultiplicity(tokens);\n    return new ModelPathImpl<true, true>(tokens, true);\n}\n\nexport function createRelativeFromTokens(tokens: readonly string[]): RelativeResolvedModelPath;\nexport function createRelativeFromTokens(tokens: readonly PathToken[]): RelativeModelPath;\nexport function createRelativeFromTokens(tokens: readonly PathToken[]): RelativeModelPath {\n    return new ModelPathImpl<false, false>(tokens, false);\n}\n\nexport function joinModelPaths(...parts: Array<ModelPath | PathToken | PathToken[]>): ModelPath {\n    let absolute = false;\n    let resultParts: PathToken[] = [];\n    for (const joinItem of parts) {\n        if (typeof joinItem === \"string\") {\n            resultParts.push(joinItem);\n        } else if (isModelPath(joinItem)) {\n            if (joinItem.isAbsolute()) {\n                absolute = true;\n                resultParts = [...joinItem.getPathPartsAsArray()];\n            } else {\n                resultParts.push(...joinItem.getPathPartsAsArray());\n            }\n        } else if (Array.isArray(joinItem)) {\n            resultParts.push(...joinItem);\n        } else if (PathTokens.isMultiToken(joinItem)) {\n            resultParts.push(joinItem);\n        }\n    }\n\n    return new ModelPathImpl(resultParts, absolute);\n}\n\nexport interface IModelPath<TResolved extends boolean, TAbsolute extends boolean>\n    extends IEquatable<IModelPath<boolean, boolean>> {\n    readonly resolved: TResolved;\n    readonly absolute: TAbsolute;\n\n    isEquals(modelPath: ModelPath, eachCurrentCollision?: EachCurrentCollision): boolean;\n    getHash(eachCurrentCollision?: EachCurrentCollision): number;\n\n    isResolved(): this is IModelPath<true, TAbsolute>;\n    isAbsolute(): this is IModelPath<TResolved, true>;\n    toAbsolute(): IModelPath<TResolved, true>;\n\n    joinWith(...path: string[]): IModelPath<TResolved, TAbsolute>;\n    joinWith(...path: PathToken[]): IModelPath<boolean, TAbsolute>;\n    joinWith(...path: Array<ResolvedModelPath | string>): IModelPath<TResolved, TAbsolute>;\n    joinWith(...path: Array<AbsoluteResolvedModelPath | string>): IModelPath<TResolved, true>;\n    joinWith(...path: Array<ModelPath | PathToken>): IModelPath<boolean, TAbsolute>;\n\n    getPathParts(): Iterable<PathTokenSpec<TResolved>>;\n    getPathPartsAsArray(): ReadonlyArray<PathTokenSpec<TResolved>>;\n    getSimpleTokensStrict(): Iterable<SimplePathToken>;\n    getSimpleTokensAsArrayStrict(): readonly SimplePathToken[];\n\n    resolveAll(instance: string): ModelPath;\n    isContainIteration(): boolean;\n    isContainCurrentIteration(): boolean;\n    isContainCurrentOrEachIteration(): boolean;\n    getLastListPath(): PathToken[];\n    isEndsWithIteration(): boolean;\n    isEndsWithCurrentIteration(): boolean;\n    isIncludes(modelPath: ModelPath): boolean;\n    getIterationRank(eachCurrentCollision?: EachCurrentCollision): number;\n    isEmpty(): boolean;\n    matchFor(modelPath: ModelPath): PathMatching;\n    startsWith(modelPath: ModelPath): boolean;\n    endsWith(modelPath: ModelPath): boolean;\n    splitByMultiplicity(): Iterable<ResolvedModelPath | typeof EachSymbol | typeof CurrentSymbol>;\n    normalize(): IModelPath<TResolved, TAbsolute>;\n    toCurrentIteration(): IModelPath<TResolved, TAbsolute>;\n    toEachIteration(): IModelPath<TResolved, TAbsolute>;\n    getAllParentPaths(): Iterable<ModelPath>;\n    trimLastStarIfLastToken(): IModelPath<TResolved, TAbsolute>;\n    getParentPath(): IModelPath<TResolved, TAbsolute>;\n    applyInstancesDirty(\n        instances: SimplePathToken[],\n        fillWithMultiplicityIfHasNoInstance?: boolean\n    ): IModelPath<TResolved, TAbsolute>;\n\n    toString(): string;\n    toLegacyPath(): string;\n}\n\nexport type ModelPath = IModelPath<boolean, boolean>;\nexport type ResolvedModelPath = IModelPath<true, boolean>;\nexport type AbsoluteModelPath = IModelPath<boolean, true>;\nexport type AbsoluteResolvedModelPath = IModelPath<true, true>;\n\nexport type RelativeModelPath = IModelPath<boolean, false>;\nexport type RelativeResolvedModelPath = IModelPath<true, false>;\n\ntype PathTokenSpec<TResolved extends boolean> = TResolved extends true ? string : PathToken;\n\ntype PathTokensSpec<TResolved extends boolean> = Array<PathTokenSpec<TResolved>>;\n\ntype ReadonlyPathTokensSpec<TResolved extends boolean> = ReadonlyArray<PathTokenSpec<TResolved>>;\n\nfunction isAllTokensResolved<TResolved extends boolean>(tokens: ReadonlyPathTokensSpec<TResolved>): TResolved {\n    // Я что-то немогу сообразить как тут всё строго написать...\n    // @ts-expect-error\n    return tokens.every(PathTokens.isSimpleToken);\n}\n\nexport class ModelPathImpl<TResolved extends boolean, TAbsolute extends boolean>\n    implements IEquatable<ModelPath>, IModelPath<TResolved, TAbsolute>\n{\n    private readonly tokens: ReadonlyPathTokensSpec<TResolved>;\n    public readonly absolute: TAbsolute;\n    private legacyPath: undefined | string;\n    private cachedHash: number | undefined;\n\n    public constructor(pathParts: ReadonlyPathTokensSpec<TResolved>, absolute: TAbsolute) {\n        this.tokens = pathParts.filter(x => x !== \"\");\n        this.absolute = absolute;\n    }\n\n    public get resolved(): TResolved {\n        return isAllTokensResolved(this.tokens);\n    }\n\n    public getPathParts(): Iterable<PathTokenSpec<TResolved>> {\n        return this.tokens;\n    }\n\n    public getPathPartsAsArray(): ReadonlyArray<PathTokenSpec<TResolved>> {\n        return this.tokens;\n    }\n\n    public *getSimpleTokensStrict(): Iterable<SimplePathToken> {\n        for (const token of this.tokens) {\n            if (!PathTokens.isSimpleToken(token)) {\n                throw new Error(\"Path must not contain spec tokens\");\n            }\n            yield token;\n        }\n    }\n\n    public getSimpleTokensAsArrayStrict(): readonly SimplePathToken[] {\n        for (const token of this.tokens) {\n            if (!PathTokens.isSimpleToken(token)) {\n                throw new Error(\"Path must not contain spec tokens\");\n            }\n        }\n        // Проверка выше гараентирует что будут только SimplePathToken.\n        // Все map и filter убраны для производительности\n        // @ts-ignore\n        return this.tokens;\n    }\n\n    public joinWith(...path: string[]): IModelPath<TResolved, TAbsolute>;\n    public joinWith(...path: PathToken[]): IModelPath<boolean, TAbsolute>;\n    public joinWith(...path: Array<ResolvedModelPath | string>): IModelPath<TResolved, TAbsolute>;\n    public joinWith(...path: Array<AbsoluteResolvedModelPath | string>): IModelPath<TResolved, true>;\n    public joinWith(...path: Array<ModelPath | PathToken>): IModelPath<boolean, TAbsolute>;\n    public joinWith(...path: Array<ModelPath | PathToken>): IModelPath<boolean, boolean> {\n        return joinModelPaths(this, ...path);\n    }\n\n    public isResolved(): this is IModelPath<true, TAbsolute> {\n        return isAllTokensResolved(this.tokens);\n    }\n\n    public resolveAll(instance: string): ModelPath {\n        const tokens = this.tokens.map(token => {\n            if (PathTokens.isSimpleToken(token)) {\n                return token;\n            } else {\n                return instance;\n            }\n        });\n\n        return new ModelPathImpl(tokens, this.absolute);\n    }\n\n    public isContainIteration(): boolean {\n        return this.tokens.some(x => x === PathTokens.each);\n    }\n\n    public isContainCurrentIteration(): boolean {\n        return this.tokens.some(x => x === PathTokens.current);\n    }\n\n    public isContainCurrentOrEachIteration(): boolean {\n        return this.tokens.some(x => x === PathTokens.current || x === PathTokens.each);\n    }\n\n    public getLastListPath(): PathToken[] {\n        if (!this.isContainIteration()) {\n            throw new Error(\"Path must contain iteration\");\n        }\n\n        // Проверка выше гарантирует, что будет PathTokens.each\n        // @ts-ignore\n        const lastIterationIndex = this.tokens.lastIndexOf(PathTokens.each);\n        return this.tokens.slice(0, lastIterationIndex);\n    }\n\n    public isEndsWithIteration(): boolean {\n        const lastItem = IterUtils.last(this.tokens);\n        return lastItem == PathTokens.each;\n    }\n\n    public isEndsWithCurrentIteration(): boolean {\n        const lastItem = IterUtils.last(this.tokens);\n        return lastItem == PathTokens.current;\n    }\n\n    public isAbsolute(): this is IModelPath<TResolved, true> {\n        return this.absolute;\n    }\n\n    public toString(): string {\n        if (this.tokens.length === 0) {\n            return \"\";\n        }\n        return (this.absolute ? \"/\" : \"\") + this.tokens.map(x => this.pathPartToString(x)).join(\"/\");\n    }\n\n    public toLegacyPath(): string {\n        return this.legacyPath ?? (this.legacyPath = this.tokens.map(x => this.pathPartToString(x)).join(\"/\"));\n    }\n\n    public isEquals(\n        modelPath: ModelPath,\n        eachCurrentCollision: EachCurrentCollision = EachCurrentCollision.AreSame\n    ): boolean {\n        if (eachCurrentCollision === EachCurrentCollision.AreSame) {\n            return this.toLegacyPath() === modelPath.toLegacyPath();\n        } else {\n            return (\n                this.isAbsolute() === modelPath.isAbsolute() &&\n                Iterator.from(IterUtils.zip(this.getPathParts(), modelPath.getPathParts())).every(\n                    ([t1, t2]) => t1 === t2\n                )\n            );\n        }\n    }\n\n    /**\n     * Всегда целое положительное беззнаковое 32-битное число\n     */\n    public getHash(eachCurrentCollision: EachCurrentCollision = EachCurrentCollision.AreSame): number {\n        if (this.cachedHash == undefined) {\n            let hash = 5381;\n            for (const token of reverseArray(this.tokens)) {\n                let currentStr: string;\n                if (PathTokens.isSimpleToken(token)) {\n                    currentStr = token;\n                } else {\n                    if (eachCurrentCollision === EachCurrentCollision.AreDifferent) {\n                        currentStr = token === PathTokens.each ? \"*\" : \"!\";\n                    } else {\n                        currentStr = \"*\";\n                    }\n                }\n                let stringIndex = currentStr.length;\n                while (stringIndex) {\n                    // tslint:disable-next-line:no-bitwise\n                    hash = (hash * 33) ^ currentStr.charCodeAt(--stringIndex);\n                }\n            }\n\n            /*\n                tslint:disable-next-line:no-bitwise\n                JavaScript does bitwise operations (like XOR, above) on 32-bit signed\n                integers. Since we want the results to be always positive, convert the\n                signed int to an unsigned by doing an unsigned bitshift.\n          */\n            this.cachedHash = hash >>> 0;\n        }\n        return this.cachedHash;\n    }\n\n    public isIncludes(modelPath: ModelPath): boolean {\n        const targetTokens = modelPath.getPathPartsAsArray();\n        if (this.tokens.length !== targetTokens.length) {\n            return false;\n        }\n        for (let i = 0; i < this.tokens.length; i++) {\n            const leftPart = this.tokens[i];\n            const rightPart = targetTokens[i];\n            if (typeof leftPart === \"string\") {\n                if (typeof rightPart === \"string\") {\n                    if (leftPart !== rightPart) {\n                        return false;\n                    }\n                    continue;\n                } else {\n                    return false;\n                }\n            } else if (leftPart === PathTokens.current || leftPart === PathTokens.each) {\n                if (typeof rightPart === \"string\") {\n                    if (!isFinite(Number(rightPart))) {\n                        return false;\n                    }\n                    continue;\n                } else {\n                    if (rightPart !== PathTokens.current && rightPart !== PathTokens.each) {\n                        return false;\n                    }\n                    continue;\n                }\n            }\n        }\n        return true;\n    }\n\n    public getIterationRank(eachCurrentCollision: EachCurrentCollision = EachCurrentCollision.AreDifferent): number {\n        return count(\n            Iterator.from(this.tokens).filter(x =>\n                eachCurrentCollision == EachCurrentCollision.AreDifferent\n                    ? x === PathTokens.each\n                    : PathTokens.isMultiToken(x)\n            )\n        );\n    }\n\n    public isEmpty(): boolean {\n        return this.tokens.length === 0;\n    }\n\n    public matchFor(modelPath: ModelPath): PathMatching {\n        if (!this.isAbsolute()) {\n            throw new Error(`Cannot match non absolute path '${this.toString()}'`);\n        }\n        if (!modelPath.isAbsolute()) {\n            throw new Error(`Cannot match non absolute path '${modelPath.toString()}'`);\n        }\n        return PathMatcher.match(this.tokens, modelPath.getPathPartsAsArray());\n    }\n\n    public startsWith(modelPath: ModelPath): boolean {\n        const thisParts = this.getPathPartsAsArray();\n        const otherParts = modelPath.getPathPartsAsArray();\n        return otherParts.every((value, index) => value === thisParts[index]);\n    }\n\n    public endsWith(modelPath: ModelPath): boolean {\n        const thisParts = this.getPathPartsAsArray().slice().reverse();\n        const otherParts = modelPath.getPathPartsAsArray().slice().reverse();\n        return otherParts.every((value, index) => value === thisParts[index]);\n    }\n\n    public *splitByMultiplicity(): Iterable<ResolvedModelPath | typeof EachSymbol | typeof CurrentSymbol> {\n        let lastSimpleParts = new ModelPathBuilder(this.isAbsolute());\n        for (const token of this.tokens) {\n            if (PathTokens.isSimpleToken(token)) {\n                lastSimpleParts.append(token);\n            } else {\n                if (!lastSimpleParts.empty) {\n                    yield lastSimpleParts.toResolvedPath();\n                    lastSimpleParts = new ModelPathBuilder(false);\n                }\n                yield token;\n            }\n        }\n        if (!lastSimpleParts.empty) {\n            yield lastSimpleParts.toResolvedPath();\n        }\n    }\n\n    public normalize(): IModelPath<TResolved, TAbsolute> {\n        const resultTokens: PathTokensSpec<TResolved> = [];\n        for (const pathPart of this.tokens) {\n            if (pathPart === \"..\") {\n                if (!resultTokens.pop()) {\n                    if (this.isAbsolute()) {\n                        throw new Error(`Path is invalid '${this.toString()}'`);\n                    } else {\n                        resultTokens.push(\"..\");\n                    }\n                }\n                continue;\n            }\n\n            if (pathPart === \".\") {\n                continue;\n            }\n            resultTokens.push(pathPart);\n        }\n        return new ModelPathImpl<TResolved, TAbsolute>(resultTokens, this.absolute);\n    }\n\n    /**\n     * @summary Спецификаторы множественности Each заменяет на Current\n     */\n    public toCurrentIteration(): IModelPath<TResolved, TAbsolute> {\n        if (this.isResolved()) {\n            return this;\n        } else {\n            // NOTE Тут не получается наложить дискриминатор\n            // @ts-expect-error\n            const pathParts: PathTokensSpec<TResolved> = this.tokens.map(x =>\n                x === PathTokens.each ? PathTokens.current : x\n            );\n            return new ModelPathImpl<TResolved, TAbsolute>(pathParts, this.absolute);\n        }\n    }\n\n    public toEachIteration(): IModelPath<TResolved, TAbsolute> {\n        if (this.isResolved()) {\n            return this;\n        } else {\n            // NOTE Тут не получается наложить дискриминатор\n            // @ts-expect-error\n            const pathParts: PathTokensSpec<TResolved> = this.tokens.map(x =>\n                x === PathTokens.current ? PathTokens.each : x\n            );\n            return new ModelPathImpl<TResolved, TAbsolute>(pathParts, this.absolute);\n        }\n    }\n\n    public toAbsolute(): IModelPath<TResolved, true> {\n        if (!this.absolute) {\n            throw new Error(`Path '${this.toLegacyPath()} is not absolute'`);\n        }\n        return new ModelPathImpl<TResolved, true>(this.tokens, true);\n    }\n\n    public *getAllParentPaths(): Iterable<ModelPath> {\n        const result = new ModelPathBuilder(this.isAbsolute());\n        for (const token of IterUtils.skipLast(this.getPathParts(), 1)) {\n            result.append(token);\n            yield result.toPath();\n        }\n    }\n\n    public trimLastStarIfLastToken(): IModelPath<TResolved, TAbsolute> {\n        const lastItem = IterUtils.last(this.tokens);\n        if (lastItem != undefined && PathTokens.isMultiToken(lastItem)) {\n            return new ModelPathImpl(this.tokens.slice(0, -1), this.absolute);\n        }\n        return this;\n    }\n\n    public getParentPath(): IModelPath<TResolved, TAbsolute> {\n        const result = new ModelPathBuilder(this.absolute);\n        for (const token of IterUtils.skipLast(this.getPathParts(), 1)) {\n            result.append(token);\n        }\n        // Тут получается так, что по другому никак\n        // @ts-expect-error\n        return result.toPath();\n    }\n\n    public applyInstancesDirty(\n        instances: SimplePathToken[],\n        fillWithMultiplicityIfHasNoInstance?: boolean\n    ): IModelPath<TResolved, TAbsolute> {\n        if (this.isResolved() || instances.length === 0) {\n            return this;\n        }\n        let instanceCounter = 0;\n        const result = new ModelPathBuilder(true);\n        for (const token of this.getPathParts()) {\n            if (PathTokens.isMultiToken(token) && instanceCounter < instances.length) {\n                const instanceOrEach =\n                    instances[instanceCounter] ??\n                    (fillWithMultiplicityIfHasNoInstance == true ? PathTokens.each : reject());\n                result.append(instanceOrEach);\n                instanceCounter++;\n            } else {\n                result.append(token);\n            }\n        }\n        // Тут получается так, что по другому никак\n        // @ts-expect-error\n        return result.toPath();\n    }\n\n    private pathPartToString(pathPart: PathToken): string {\n        if (typeof pathPart === \"string\") {\n            return pathPart;\n        }\n        if (pathPart === PathTokens.each) {\n            return \"*\";\n        }\n        if (pathPart === PathTokens.current) {\n            return \"*\";\n        }\n        throw new Error(`Unknown path part specified: ${ensureAndGetString(pathPart)}`);\n    }\n}\n"],"mappings":"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","ignoreList":[]}