@elmethis/core 1.0.0-alpha.149 → 1.0.0-alpha.150

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/serializer/json-serializer.mjs

@@ -1,202 +0,0 @@
-import { URI } from "../../../../../vscode-uri@3.0.8/node_modules/vscode-uri/lib/esm/index.mjs";
-import { isReference, isAstNode } from "../syntax-tree.mjs";
-import { getDocument } from "../utils/ast-utils.mjs";
-import { findNodesForProperty } from "../utils/grammar-utils.mjs";
-function isAstNodeWithComment(node) {
-  return typeof node.$comment === "string";
-}
-function isIntermediateReference(obj) {
-  return typeof obj === "object" && !!obj && ("$ref" in obj || "$error" in obj);
-}
-class DefaultJsonSerializer {
-  constructor(services) {
-    this.ignoreProperties = /* @__PURE__ */ new Set(["$container", "$containerProperty", "$containerIndex", "$document", "$cstNode"]);
-    this.langiumDocuments = services.shared.workspace.LangiumDocuments;
-    this.astNodeLocator = services.workspace.AstNodeLocator;
-    this.nameProvider = services.references.NameProvider;
-    this.commentProvider = services.documentation.CommentProvider;
-  }
-  serialize(node, options) {
-    const serializeOptions = options !== null && options !== void 0 ? options : {};
-    const specificReplacer = options === null || options === void 0 ? void 0 : options.replacer;
-    const defaultReplacer = (key, value) => this.replacer(key, value, serializeOptions);
-    const replacer = specificReplacer ? (key, value) => specificReplacer(key, value, defaultReplacer) : defaultReplacer;
-    try {
-      this.currentDocument = getDocument(node);
-      return JSON.stringify(node, replacer, options === null || options === void 0 ? void 0 : options.space);
-    } finally {
-      this.currentDocument = void 0;
-    }
-  }
-  deserialize(content, options) {
-    const deserializeOptions = options !== null && options !== void 0 ? options : {};
-    const root = JSON.parse(content);
-    this.linkNode(root, root, deserializeOptions);
-    return root;
-  }
-  replacer(key, value, { refText, sourceText, textRegions, comments, uriConverter }) {
-    var _a, _b, _c, _d;
-    if (this.ignoreProperties.has(key)) {
-      return void 0;
-    } else if (isReference(value)) {
-      const refValue = value.ref;
-      const $refText = refText ? value.$refText : void 0;
-      if (refValue) {
-        const targetDocument = getDocument(refValue);
-        let targetUri = "";
-        if (this.currentDocument && this.currentDocument !== targetDocument) {
-          if (uriConverter) {
-            targetUri = uriConverter(targetDocument.uri, value);
-          } else {
-            targetUri = targetDocument.uri.toString();
-          }
-        }
-        const targetPath = this.astNodeLocator.getAstNodePath(refValue);
-        return {
-          $ref: `${targetUri}#${targetPath}`,
-          $refText
-        };
-      } else {
-        return {
-          $error: (_b = (_a = value.error) === null || _a === void 0 ? void 0 : _a.message) !== null && _b !== void 0 ? _b : "Could not resolve reference",
-          $refText
-        };
-      }
-    } else if (isAstNode(value)) {
-      let astNode = void 0;
-      if (textRegions) {
-        astNode = this.addAstNodeRegionWithAssignmentsTo(Object.assign({}, value));
-        if ((!key || value.$document) && (astNode === null || astNode === void 0 ? void 0 : astNode.$textRegion)) {
-          astNode.$textRegion.documentURI = (_c = this.currentDocument) === null || _c === void 0 ? void 0 : _c.uri.toString();
-        }
-      }
-      if (sourceText && !key) {
-        astNode !== null && astNode !== void 0 ? astNode : astNode = Object.assign({}, value);
-        astNode.$sourceText = (_d = value.$cstNode) === null || _d === void 0 ? void 0 : _d.text;
-      }
-      if (comments) {
-        astNode !== null && astNode !== void 0 ? astNode : astNode = Object.assign({}, value);
-        const comment = this.commentProvider.getComment(value);
-        if (comment) {
-          astNode.$comment = comment.replace(/\r/g, "");
-        }
-      }
-      return astNode !== null && astNode !== void 0 ? astNode : value;
-    } else {
-      return value;
-    }
-  }
-  addAstNodeRegionWithAssignmentsTo(node) {
-    const createDocumentSegment = (cstNode) => ({
-      offset: cstNode.offset,
-      end: cstNode.end,
-      length: cstNode.length,
-      range: cstNode.range
-    });
-    if (node.$cstNode) {
-      const textRegion = node.$textRegion = createDocumentSegment(node.$cstNode);
-      const assignments = textRegion.assignments = {};
-      Object.keys(node).filter((key) => !key.startsWith("$")).forEach((key) => {
-        const propertyAssignments = findNodesForProperty(node.$cstNode, key).map(createDocumentSegment);
-        if (propertyAssignments.length !== 0) {
-          assignments[key] = propertyAssignments;
-        }
-      });
-      return node;
-    }
-    return void 0;
-  }
-  linkNode(node, root, options, container, containerProperty, containerIndex) {
-    for (const [propertyName, item] of Object.entries(node)) {
-      if (Array.isArray(item)) {
-        for (let index = 0; index < item.length; index++) {
-          const element = item[index];
-          if (isIntermediateReference(element)) {
-            item[index] = this.reviveReference(node, propertyName, root, element, options);
-          } else if (isAstNode(element)) {
-            this.linkNode(element, root, options, node, propertyName, index);
-          }
-        }
-      } else if (isIntermediateReference(item)) {
-        node[propertyName] = this.reviveReference(node, propertyName, root, item, options);
-      } else if (isAstNode(item)) {
-        this.linkNode(item, root, options, node, propertyName);
-      }
-    }
-    const mutable = node;
-    mutable.$container = container;
-    mutable.$containerProperty = containerProperty;
-    mutable.$containerIndex = containerIndex;
-  }
-  reviveReference(container, property, root, reference, options) {
-    let refText = reference.$refText;
-    let error = reference.$error;
-    if (reference.$ref) {
-      const ref = this.getRefNode(root, reference.$ref, options.uriConverter);
-      if (isAstNode(ref)) {
-        if (!refText) {
-          refText = this.nameProvider.getName(ref);
-        }
-        return {
-          $refText: refText !== null && refText !== void 0 ? refText : "",
-          ref
-        };
-      } else {
-        error = ref;
-      }
-    }
-    if (error) {
-      const ref = {
-        $refText: refText !== null && refText !== void 0 ? refText : ""
-      };
-      ref.error = {
-        container,
-        property,
-        message: error,
-        reference: ref
-      };
-      return ref;
-    } else {
-      return void 0;
-    }
-  }
-  getRefNode(root, uri, uriConverter) {
-    try {
-      const fragmentIndex = uri.indexOf("#");
-      if (fragmentIndex === 0) {
-        const node2 = this.astNodeLocator.getAstNode(root, uri.substring(1));
-        if (!node2) {
-          return "Could not resolve path: " + uri;
-        }
-        return node2;
-      }
-      if (fragmentIndex < 0) {
-        const documentUri2 = uriConverter ? uriConverter(uri) : URI.parse(uri);
-        const document2 = this.langiumDocuments.getDocument(documentUri2);
-        if (!document2) {
-          return "Could not find document for URI: " + uri;
-        }
-        return document2.parseResult.value;
-      }
-      const documentUri = uriConverter ? uriConverter(uri.substring(0, fragmentIndex)) : URI.parse(uri.substring(0, fragmentIndex));
-      const document = this.langiumDocuments.getDocument(documentUri);
-      if (!document) {
-        return "Could not find document for URI: " + uri;
-      }
-      if (fragmentIndex === uri.length - 1) {
-        return document.parseResult.value;
-      }
-      const node = this.astNodeLocator.getAstNode(document.parseResult.value, uri.substring(fragmentIndex + 1));
-      if (!node) {
-        return "Could not resolve URI: " + uri;
-      }
-      return node;
-    } catch (err) {
-      return String(err);
-    }
-  }
-}
-export {
-  DefaultJsonSerializer,
-  isAstNodeWithComment
-};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/service-registry.mjs

@@ -1,69 +0,0 @@
-import { UriUtils } from "./utils/uri-utils.mjs";
-class DefaultServiceRegistry {
-  /**
-   * @deprecated Use the new `fileExtensionMap` (or `languageIdMap`) property instead.
-   */
-  get map() {
-    return this.fileExtensionMap;
-  }
-  constructor(services) {
-    this.languageIdMap = /* @__PURE__ */ new Map();
-    this.fileExtensionMap = /* @__PURE__ */ new Map();
-    this.textDocuments = services === null || services === void 0 ? void 0 : services.workspace.TextDocuments;
-  }
-  register(language) {
-    const data = language.LanguageMetaData;
-    for (const ext of data.fileExtensions) {
-      if (this.fileExtensionMap.has(ext)) {
-        console.warn(`The file extension ${ext} is used by multiple languages. It is now assigned to '${data.languageId}'.`);
-      }
-      this.fileExtensionMap.set(ext, language);
-    }
-    this.languageIdMap.set(data.languageId, language);
-    if (this.languageIdMap.size === 1) {
-      this.singleton = language;
-    } else {
-      this.singleton = void 0;
-    }
-  }
-  getServices(uri) {
-    var _a, _b;
-    if (this.singleton !== void 0) {
-      return this.singleton;
-    }
-    if (this.languageIdMap.size === 0) {
-      throw new Error("The service registry is empty. Use `register` to register the services of a language.");
-    }
-    const languageId = (_b = (_a = this.textDocuments) === null || _a === void 0 ? void 0 : _a.get(uri)) === null || _b === void 0 ? void 0 : _b.languageId;
-    if (languageId !== void 0) {
-      const services2 = this.languageIdMap.get(languageId);
-      if (services2) {
-        return services2;
-      }
-    }
-    const ext = UriUtils.extname(uri);
-    const services = this.fileExtensionMap.get(ext);
-    if (!services) {
-      if (languageId) {
-        throw new Error(`The service registry contains no services for the extension '${ext}' for language '${languageId}'.`);
-      } else {
-        throw new Error(`The service registry contains no services for the extension '${ext}'.`);
-      }
-    }
-    return services;
-  }
-  hasServices(uri) {
-    try {
-      this.getServices(uri);
-      return true;
-    } catch (_a) {
-      return false;
-    }
-  }
-  get all() {
-    return Array.from(this.languageIdMap.values());
-  }
-}
-export {
-  DefaultServiceRegistry
-};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/syntax-tree.mjs

@@ -1,73 +0,0 @@
-function isAstNode(obj) {
-  return typeof obj === "object" && obj !== null && typeof obj.$type === "string";
-}
-function isReference(obj) {
-  return typeof obj === "object" && obj !== null && typeof obj.$refText === "string";
-}
-function isAstNodeDescription(obj) {
-  return typeof obj === "object" && obj !== null && typeof obj.name === "string" && typeof obj.type === "string" && typeof obj.path === "string";
-}
-function isLinkingError(obj) {
-  return typeof obj === "object" && obj !== null && isAstNode(obj.container) && isReference(obj.reference) && typeof obj.message === "string";
-}
-class AbstractAstReflection {
-  constructor() {
-    this.subtypes = {};
-    this.allSubtypes = {};
-  }
-  isInstance(node, type) {
-    return isAstNode(node) && this.isSubtype(node.$type, type);
-  }
-  isSubtype(subtype, supertype) {
-    if (subtype === supertype) {
-      return true;
-    }
-    let nested = this.subtypes[subtype];
-    if (!nested) {
-      nested = this.subtypes[subtype] = {};
-    }
-    const existing = nested[supertype];
-    if (existing !== void 0) {
-      return existing;
-    } else {
-      const result = this.computeIsSubtype(subtype, supertype);
-      nested[supertype] = result;
-      return result;
-    }
-  }
-  getAllSubTypes(type) {
-    const existing = this.allSubtypes[type];
-    if (existing) {
-      return existing;
-    } else {
-      const allTypes = this.getAllTypes();
-      const types = [];
-      for (const possibleSubType of allTypes) {
-        if (this.isSubtype(possibleSubType, type)) {
-          types.push(possibleSubType);
-        }
-      }
-      this.allSubtypes[type] = types;
-      return types;
-    }
-  }
-}
-function isCompositeCstNode(node) {
-  return typeof node === "object" && node !== null && Array.isArray(node.content);
-}
-function isLeafCstNode(node) {
-  return typeof node === "object" && node !== null && typeof node.tokenType === "object";
-}
-function isRootCstNode(node) {
-  return isCompositeCstNode(node) && typeof node.fullText === "string";
-}
-export {
-  AbstractAstReflection,
-  isAstNode,
-  isAstNodeDescription,
-  isCompositeCstNode,
-  isLeafCstNode,
-  isLinkingError,
-  isReference,
-  isRootCstNode
-};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/ast-utils.mjs

@@ -1,159 +0,0 @@
-import { isAstNode, isReference } from "../syntax-tree.mjs";
-import { TreeStreamImpl, StreamImpl, DONE_RESULT } from "./stream.mjs";
-import { inRange } from "./cst-utils.mjs";
-function linkContentToContainer(node) {
-  for (const [name, value] of Object.entries(node)) {
-    if (!name.startsWith("$")) {
-      if (Array.isArray(value)) {
-        value.forEach((item, index) => {
-          if (isAstNode(item)) {
-            item.$container = node;
-            item.$containerProperty = name;
-            item.$containerIndex = index;
-          }
-        });
-      } else if (isAstNode(value)) {
-        value.$container = node;
-        value.$containerProperty = name;
-      }
-    }
-  }
-}
-function getContainerOfType(node, typePredicate) {
-  let item = node;
-  while (item) {
-    if (typePredicate(item)) {
-      return item;
-    }
-    item = item.$container;
-  }
-  return void 0;
-}
-function getDocument(node) {
-  const rootNode = findRootNode(node);
-  const result = rootNode.$document;
-  if (!result) {
-    throw new Error("AST node has no document.");
-  }
-  return result;
-}
-function findRootNode(node) {
-  while (node.$container) {
-    node = node.$container;
-  }
-  return node;
-}
-function streamContents(node, options) {
-  if (!node) {
-    throw new Error("Node must be an AstNode.");
-  }
-  const range = options === null || options === void 0 ? void 0 : options.range;
-  return new StreamImpl(() => ({
-    keys: Object.keys(node),
-    keyIndex: 0,
-    arrayIndex: 0
-  }), (state) => {
-    while (state.keyIndex < state.keys.length) {
-      const property = state.keys[state.keyIndex];
-      if (!property.startsWith("$")) {
-        const value = node[property];
-        if (isAstNode(value)) {
-          state.keyIndex++;
-          if (isAstNodeInRange(value, range)) {
-            return { done: false, value };
-          }
-        } else if (Array.isArray(value)) {
-          while (state.arrayIndex < value.length) {
-            const index = state.arrayIndex++;
-            const element = value[index];
-            if (isAstNode(element) && isAstNodeInRange(element, range)) {
-              return { done: false, value: element };
-            }
-          }
-          state.arrayIndex = 0;
-        }
-      }
-      state.keyIndex++;
-    }
-    return DONE_RESULT;
-  });
-}
-function streamAllContents(root, options) {
-  if (!root) {
-    throw new Error("Root node must be an AstNode.");
-  }
-  return new TreeStreamImpl(root, (node) => streamContents(node, options));
-}
-function streamAst(root, options) {
-  if (!root) {
-    throw new Error("Root node must be an AstNode.");
-  }
-  return new TreeStreamImpl(root, (node) => streamContents(node, options), { includeRoot: true });
-}
-function isAstNodeInRange(astNode, range) {
-  var _a;
-  if (!range) {
-    return true;
-  }
-  const nodeRange = (_a = astNode.$cstNode) === null || _a === void 0 ? void 0 : _a.range;
-  if (!nodeRange) {
-    return false;
-  }
-  return inRange(nodeRange, range);
-}
-function streamReferences(node) {
-  return new StreamImpl(() => ({
-    keys: Object.keys(node),
-    keyIndex: 0,
-    arrayIndex: 0
-  }), (state) => {
-    while (state.keyIndex < state.keys.length) {
-      const property = state.keys[state.keyIndex];
-      if (!property.startsWith("$")) {
-        const value = node[property];
-        if (isReference(value)) {
-          state.keyIndex++;
-          return { done: false, value: { reference: value, container: node, property } };
-        } else if (Array.isArray(value)) {
-          while (state.arrayIndex < value.length) {
-            const index = state.arrayIndex++;
-            const element = value[index];
-            if (isReference(element)) {
-              return { done: false, value: { reference: element, container: node, property, index } };
-            }
-          }
-          state.arrayIndex = 0;
-        }
-      }
-      state.keyIndex++;
-    }
-    return DONE_RESULT;
-  });
-}
-function assignMandatoryProperties(reflection, node) {
-  const typeMetaData = reflection.getTypeMetaData(node.$type);
-  const genericNode = node;
-  for (const property of typeMetaData.properties) {
-    if (property.defaultValue !== void 0 && genericNode[property.name] === void 0) {
-      genericNode[property.name] = copyDefaultValue(property.defaultValue);
-    }
-  }
-}
-function copyDefaultValue(propertyType) {
-  if (Array.isArray(propertyType)) {
-    return [...propertyType.map(copyDefaultValue)];
-  } else {
-    return propertyType;
-  }
-}
-export {
-  assignMandatoryProperties,
-  findRootNode,
-  getContainerOfType,
-  getDocument,
-  linkContentToContainer,
-  streamAllContents,
-  streamAst,
-  streamContents,
-  streamReferences
-};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/utils/caching.mjs

@@ -1,137 +0,0 @@
-class DisposableCache {
-  constructor() {
-    this.toDispose = [];
-    this.isDisposed = false;
-  }
-  onDispose(disposable) {
-    this.toDispose.push(disposable);
-  }
-  dispose() {
-    this.throwIfDisposed();
-    this.clear();
-    this.isDisposed = true;
-    this.toDispose.forEach((disposable) => disposable.dispose());
-  }
-  throwIfDisposed() {
-    if (this.isDisposed) {
-      throw new Error("This cache has already been disposed");
-    }
-  }
-}
-class SimpleCache extends DisposableCache {
-  constructor() {
-    super(...arguments);
-    this.cache = /* @__PURE__ */ new Map();
-  }
-  has(key) {
-    this.throwIfDisposed();
-    return this.cache.has(key);
-  }
-  set(key, value) {
-    this.throwIfDisposed();
-    this.cache.set(key, value);
-  }
-  get(key, provider) {
-    this.throwIfDisposed();
-    if (this.cache.has(key)) {
-      return this.cache.get(key);
-    } else if (provider) {
-      const value = provider();
-      this.cache.set(key, value);
-      return value;
-    } else {
-      return void 0;
-    }
-  }
-  delete(key) {
-    this.throwIfDisposed();
-    return this.cache.delete(key);
-  }
-  clear() {
-    this.throwIfDisposed();
-    this.cache.clear();
-  }
-}
-class ContextCache extends DisposableCache {
-  constructor(converter) {
-    super();
-    this.cache = /* @__PURE__ */ new Map();
-    this.converter = converter !== null && converter !== void 0 ? converter : (value) => value;
-  }
-  has(contextKey, key) {
-    this.throwIfDisposed();
-    return this.cacheForContext(contextKey).has(key);
-  }
-  set(contextKey, key, value) {
-    this.throwIfDisposed();
-    this.cacheForContext(contextKey).set(key, value);
-  }
-  get(contextKey, key, provider) {
-    this.throwIfDisposed();
-    const contextCache = this.cacheForContext(contextKey);
-    if (contextCache.has(key)) {
-      return contextCache.get(key);
-    } else if (provider) {
-      const value = provider();
-      contextCache.set(key, value);
-      return value;
-    } else {
-      return void 0;
-    }
-  }
-  delete(contextKey, key) {
-    this.throwIfDisposed();
-    return this.cacheForContext(contextKey).delete(key);
-  }
-  clear(contextKey) {
-    this.throwIfDisposed();
-    if (contextKey) {
-      const mapKey = this.converter(contextKey);
-      this.cache.delete(mapKey);
-    } else {
-      this.cache.clear();
-    }
-  }
-  cacheForContext(contextKey) {
-    const mapKey = this.converter(contextKey);
-    let documentCache = this.cache.get(mapKey);
-    if (!documentCache) {
-      documentCache = /* @__PURE__ */ new Map();
-      this.cache.set(mapKey, documentCache);
-    }
-    return documentCache;
-  }
-}
-class WorkspaceCache extends SimpleCache {
-  /**
-   * Creates a new workspace cache.
-   *
-   * @param sharedServices Service container instance to hook into document lifecycle events.
-   * @param state Optional document state on which the cache should evict.
-   * If not provided, the cache will evict on `DocumentBuilder#onUpdate`.
-   * *Deleted* documents are considered in both cases.
-   */
-  constructor(sharedServices, state) {
-    super();
-    if (state) {
-      this.toDispose.push(sharedServices.workspace.DocumentBuilder.onBuildPhase(state, () => {
-        this.clear();
-      }));
-      this.toDispose.push(sharedServices.workspace.DocumentBuilder.onUpdate((_changed, deleted) => {
-        if (deleted.length > 0) {
-          this.clear();
-        }
-      }));
-    } else {
-      this.toDispose.push(sharedServices.workspace.DocumentBuilder.onUpdate(() => {
-        this.clear();
-      }));
-    }
-  }
-}
-export {
-  ContextCache,
-  DisposableCache,
-  SimpleCache,
-  WorkspaceCache
-};