@elmethis/core 1.0.0-alpha.146 → 1.0.0-alpha.148

package/dist/node_modules/.pnpm/khroma@2.1.0/node_modules/khroma/dist/methods/mix.mjs

@@ -0,0 +1,20 @@
+import Color from "../color/index.mjs";
+import rgba from "./rgba.mjs";
+const mix = (color1, color2, weight = 50) => {
+  const { r: r1, g: g1, b: b1, a: a1 } = Color.parse(color1);
+  const { r: r2, g: g2, b: b2, a: a2 } = Color.parse(color2);
+  const weightScale = weight / 100;
+  const weightNormalized = weightScale * 2 - 1;
+  const alphaDelta = a1 - a2;
+  const weight1combined = weightNormalized * alphaDelta === -1 ? weightNormalized : (weightNormalized + alphaDelta) / (1 + weightNormalized * alphaDelta);
+  const weight1 = (weight1combined + 1) / 2;
+  const weight2 = 1 - weight1;
+  const r = r1 * weight1 + r2 * weight2;
+  const g = g1 * weight1 + g2 * weight2;
+  const b = b1 * weight1 + b2 * weight2;
+  const a = a1 * weightScale + a2 * (1 - weightScale);
+  return rgba(r, g, b, a);
+};
+export {
+  mix as default
+};

package/dist/node_modules/.pnpm/khroma@2.1.0/node_modules/khroma/dist/methods/rgba.mjs

@@ -0,0 +1,18 @@
+import Utils from "../utils/index.mjs";
+import channels from "../channels/reusable.mjs";
+import Color from "../color/index.mjs";
+import change from "./change.mjs";
+const rgba = (r, g, b = 0, a = 1) => {
+  if (typeof r !== "number")
+    return change(r, { a: g });
+  const channels$1 = channels.set({
+    r: Utils.channel.clamp.r(r),
+    g: Utils.channel.clamp.g(g),
+    b: Utils.channel.clamp.b(b),
+    a: Utils.channel.clamp.a(a)
+  });
+  return Color.stringify(channels$1);
+};
+export {
+  rgba as default
+};

package/dist/node_modules/.pnpm/khroma@2.1.0/node_modules/khroma/dist/utils/channel.mjs

@@ -0,0 +1,95 @@
+const Channel = {
+  /* CLAMP */
+  min: {
+    r: 0,
+    g: 0,
+    b: 0,
+    s: 0,
+    l: 0,
+    a: 0
+  },
+  max: {
+    r: 255,
+    g: 255,
+    b: 255,
+    h: 360,
+    s: 100,
+    l: 100,
+    a: 1
+  },
+  clamp: {
+    r: (r) => r >= 255 ? 255 : r < 0 ? 0 : r,
+    g: (g) => g >= 255 ? 255 : g < 0 ? 0 : g,
+    b: (b) => b >= 255 ? 255 : b < 0 ? 0 : b,
+    h: (h) => h % 360,
+    s: (s) => s >= 100 ? 100 : s < 0 ? 0 : s,
+    l: (l) => l >= 100 ? 100 : l < 0 ? 0 : l,
+    a: (a) => a >= 1 ? 1 : a < 0 ? 0 : a
+  },
+  /* CONVERSION */
+  //SOURCE: https://planetcalc.com/7779
+  toLinear: (c) => {
+    const n = c / 255;
+    return c > 0.03928 ? Math.pow((n + 0.055) / 1.055, 2.4) : n / 12.92;
+  },
+  //SOURCE: https://gist.github.com/mjackson/5311256
+  hue2rgb: (p, q, t) => {
+    if (t < 0)
+      t += 1;
+    if (t > 1)
+      t -= 1;
+    if (t < 1 / 6)
+      return p + (q - p) * 6 * t;
+    if (t < 1 / 2)
+      return q;
+    if (t < 2 / 3)
+      return p + (q - p) * (2 / 3 - t) * 6;
+    return p;
+  },
+  hsl2rgb: ({ h, s, l }, channel) => {
+    if (!s)
+      return l * 2.55;
+    h /= 360;
+    s /= 100;
+    l /= 100;
+    const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+    const p = 2 * l - q;
+    switch (channel) {
+      case "r":
+        return Channel.hue2rgb(p, q, h + 1 / 3) * 255;
+      case "g":
+        return Channel.hue2rgb(p, q, h) * 255;
+      case "b":
+        return Channel.hue2rgb(p, q, h - 1 / 3) * 255;
+    }
+  },
+  rgb2hsl: ({ r, g, b }, channel) => {
+    r /= 255;
+    g /= 255;
+    b /= 255;
+    const max = Math.max(r, g, b);
+    const min = Math.min(r, g, b);
+    const l = (max + min) / 2;
+    if (channel === "l")
+      return l * 100;
+    if (max === min)
+      return 0;
+    const d = max - min;
+    const s = l > 0.5 ? d / (2 - max - min) : d / (max + min);
+    if (channel === "s")
+      return s * 100;
+    switch (max) {
+      case r:
+        return ((g - b) / d + (g < b ? 6 : 0)) * 60;
+      case g:
+        return ((b - r) / d + 2) * 60;
+      case b:
+        return ((r - g) / d + 4) * 60;
+      default:
+        return -1;
+    }
+  }
+};
+export {
+  Channel as default
+};

package/dist/node_modules/.pnpm/khroma@2.1.0/node_modules/khroma/dist/utils/index.mjs

@@ -0,0 +1,11 @@
+import Channel from "./channel.mjs";
+import Lang from "./lang.mjs";
+import Unit from "./unit.mjs";
+const Utils = {
+  channel: Channel,
+  lang: Lang,
+  unit: Unit
+};
+export {
+  Utils as default
+};

package/dist/node_modules/.pnpm/khroma@2.1.0/node_modules/khroma/dist/utils/lang.mjs

@@ -0,0 +1,14 @@
+const Lang = {
+  /* API */
+  clamp: (number, lower, upper) => {
+    if (lower > upper)
+      return Math.min(lower, Math.max(upper, number));
+    return Math.min(upper, Math.max(lower, number));
+  },
+  round: (number) => {
+    return Math.round(number * 1e10) / 1e10;
+  }
+};
+export {
+  Lang as default
+};

package/dist/node_modules/.pnpm/khroma@2.1.0/node_modules/khroma/dist/utils/unit.mjs

@@ -0,0 +1,10 @@
+const Unit = {
+  /* API */
+  dec2hex: (dec) => {
+    const hex = Math.round(dec).toString(16);
+    return hex.length > 1 ? hex : `0${hex}`;
+  }
+};
+export {
+  Unit as default
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/default-module.mjs

@@ -0,0 +1,87 @@
+import { createGrammarConfig } from "./languages/grammar-config.mjs";
+import { createCompletionParser } from "./parser/completion-parser-builder.mjs";
+import { createLangiumParser } from "./parser/langium-parser-builder.mjs";
+import { DefaultTokenBuilder } from "./parser/token-builder.mjs";
+import { DefaultValueConverter } from "./parser/value-converter.mjs";
+import { DefaultLinker } from "./references/linker.mjs";
+import { DefaultNameProvider } from "./references/name-provider.mjs";
+import { DefaultReferences } from "./references/references.mjs";
+import { DefaultScopeComputation } from "./references/scope-computation.mjs";
+import { DefaultScopeProvider } from "./references/scope-provider.mjs";
+import { DefaultJsonSerializer } from "./serializer/json-serializer.mjs";
+import { DefaultServiceRegistry } from "./service-registry.mjs";
+import { DefaultDocumentValidator } from "./validation/document-validator.mjs";
+import { ValidationRegistry } from "./validation/validation-registry.mjs";
+import { DefaultReferenceDescriptionProvider, DefaultAstNodeDescriptionProvider } from "./workspace/ast-descriptions.mjs";
+import { DefaultAstNodeLocator } from "./workspace/ast-node-locator.mjs";
+import { DefaultConfigurationProvider } from "./workspace/configuration.mjs";
+import { DefaultDocumentBuilder } from "./workspace/document-builder.mjs";
+import { DefaultLangiumDocumentFactory, DefaultLangiumDocuments } from "./workspace/documents.mjs";
+import { DefaultIndexManager } from "./workspace/index-manager.mjs";
+import { DefaultWorkspaceManager } from "./workspace/workspace-manager.mjs";
+import { DefaultLexerErrorMessageProvider, DefaultLexer } from "./parser/lexer.mjs";
+import { JSDocDocumentationProvider } from "./documentation/documentation-provider.mjs";
+import { DefaultCommentProvider } from "./documentation/comment-provider.mjs";
+import { LangiumParserErrorMessageProvider } from "./parser/langium-parser.mjs";
+import { DefaultAsyncParser } from "./parser/async-parser.mjs";
+import { DefaultWorkspaceLock } from "./workspace/workspace-lock.mjs";
+import { DefaultHydrator } from "./serializer/hydrator.mjs";
+function createDefaultCoreModule(context) {
+  return {
+    documentation: {
+      CommentProvider: (services) => new DefaultCommentProvider(services),
+      DocumentationProvider: (services) => new JSDocDocumentationProvider(services)
+    },
+    parser: {
+      AsyncParser: (services) => new DefaultAsyncParser(services),
+      GrammarConfig: (services) => createGrammarConfig(services),
+      LangiumParser: (services) => createLangiumParser(services),
+      CompletionParser: (services) => createCompletionParser(services),
+      ValueConverter: () => new DefaultValueConverter(),
+      TokenBuilder: () => new DefaultTokenBuilder(),
+      Lexer: (services) => new DefaultLexer(services),
+      ParserErrorMessageProvider: () => new LangiumParserErrorMessageProvider(),
+      LexerErrorMessageProvider: () => new DefaultLexerErrorMessageProvider()
+    },
+    workspace: {
+      AstNodeLocator: () => new DefaultAstNodeLocator(),
+      AstNodeDescriptionProvider: (services) => new DefaultAstNodeDescriptionProvider(services),
+      ReferenceDescriptionProvider: (services) => new DefaultReferenceDescriptionProvider(services)
+    },
+    references: {
+      Linker: (services) => new DefaultLinker(services),
+      NameProvider: () => new DefaultNameProvider(),
+      ScopeProvider: (services) => new DefaultScopeProvider(services),
+      ScopeComputation: (services) => new DefaultScopeComputation(services),
+      References: (services) => new DefaultReferences(services)
+    },
+    serializer: {
+      Hydrator: (services) => new DefaultHydrator(services),
+      JsonSerializer: (services) => new DefaultJsonSerializer(services)
+    },
+    validation: {
+      DocumentValidator: (services) => new DefaultDocumentValidator(services),
+      ValidationRegistry: (services) => new ValidationRegistry(services)
+    },
+    shared: () => context.shared
+  };
+}
+function createDefaultSharedCoreModule(context) {
+  return {
+    ServiceRegistry: (services) => new DefaultServiceRegistry(services),
+    workspace: {
+      LangiumDocuments: (services) => new DefaultLangiumDocuments(services),
+      LangiumDocumentFactory: (services) => new DefaultLangiumDocumentFactory(services),
+      DocumentBuilder: (services) => new DefaultDocumentBuilder(services),
+      IndexManager: (services) => new DefaultIndexManager(services),
+      WorkspaceManager: (services) => new DefaultWorkspaceManager(services),
+      FileSystemProvider: (services) => context.fileSystemProvider(services),
+      WorkspaceLock: () => new DefaultWorkspaceLock(),
+      ConfigurationProvider: (services) => new DefaultConfigurationProvider(services)
+    }
+  };
+}
+export {
+  createDefaultCoreModule,
+  createDefaultSharedCoreModule
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/dependency-injection.mjs

@@ -0,0 +1,74 @@
+var Module;
+(function(Module2) {
+  Module2.merge = (m1, m2) => _merge(_merge({}, m1), m2);
+})(Module || (Module = {}));
+function inject(module1, module2, module3, module4, module5, module6, module7, module8, module9) {
+  const module = [module1, module2, module3, module4, module5, module6, module7, module8, module9].reduce(_merge, {});
+  return _inject(module);
+}
+const isProxy = Symbol("isProxy");
+function _inject(module, injector) {
+  const proxy = new Proxy({}, {
+    deleteProperty: () => false,
+    set: () => {
+      throw new Error("Cannot set property on injected service container");
+    },
+    get: (obj, prop) => {
+      if (prop === isProxy) {
+        return true;
+      } else {
+        return _resolve(obj, prop, module, injector || proxy);
+      }
+    },
+    getOwnPropertyDescriptor: (obj, prop) => (_resolve(obj, prop, module, injector || proxy), Object.getOwnPropertyDescriptor(obj, prop)),
+    // used by for..in
+    has: (_, prop) => prop in module,
+    // used by ..in..
+    ownKeys: () => [...Object.getOwnPropertyNames(module)]
+    // used by for..in
+  });
+  return proxy;
+}
+const __requested__ = Symbol();
+function _resolve(obj, prop, module, injector) {
+  if (prop in obj) {
+    if (obj[prop] instanceof Error) {
+      throw new Error("Construction failure. Please make sure that your dependencies are constructable.", { cause: obj[prop] });
+    }
+    if (obj[prop] === __requested__) {
+      throw new Error('Cycle detected. Please make "' + String(prop) + '" lazy. Visit https://langium.org/docs/reference/configuration-services/#resolving-cyclic-dependencies');
+    }
+    return obj[prop];
+  } else if (prop in module) {
+    const value = module[prop];
+    obj[prop] = __requested__;
+    try {
+      obj[prop] = typeof value === "function" ? value(injector) : _inject(value, injector);
+    } catch (error) {
+      obj[prop] = error instanceof Error ? error : void 0;
+      throw error;
+    }
+    return obj[prop];
+  } else {
+    return void 0;
+  }
+}
+function _merge(target, source) {
+  if (source) {
+    for (const [key, value2] of Object.entries(source)) {
+      if (value2 !== void 0) {
+        const value1 = target[key];
+        if (value1 !== null && value2 !== null && typeof value1 === "object" && typeof value2 === "object") {
+          target[key] = _merge(value1, value2);
+        } else {
+          target[key] = value2;
+        }
+      }
+    }
+  }
+  return target;
+}
+export {
+  Module,
+  inject
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/documentation/comment-provider.mjs

@@ -0,0 +1,17 @@
+import { isAstNodeWithComment } from "../serializer/json-serializer.mjs";
+import { findCommentNode } from "../utils/cst-utils.mjs";
+class DefaultCommentProvider {
+  constructor(services) {
+    this.grammarConfig = () => services.parser.GrammarConfig;
+  }
+  getComment(node) {
+    var _a;
+    if (isAstNodeWithComment(node)) {
+      return node.$comment;
+    }
+    return (_a = findCommentNode(node.$cstNode, this.grammarConfig().multilineCommentRules)) === null || _a === void 0 ? void 0 : _a.text;
+  }
+}
+export {
+  DefaultCommentProvider
+};

package/dist/node_modules/.pnpm/langium@3.3.1/node_modules/langium/lib/documentation/documentation-provider.mjs

@@ -0,0 +1,62 @@
+import { getDocument } from "../utils/ast-utils.mjs";
+import { isJSDoc, parseJSDoc } from "./jsdoc.mjs";
+class JSDocDocumentationProvider {
+  constructor(services) {
+    this.indexManager = services.shared.workspace.IndexManager;
+    this.commentProvider = services.documentation.CommentProvider;
+  }
+  getDocumentation(node) {
+    const comment = this.commentProvider.getComment(node);
+    if (comment && isJSDoc(comment)) {
+      const parsedJSDoc = parseJSDoc(comment);
+      return parsedJSDoc.toMarkdown({
+        renderLink: (link, display) => {
+          return this.documentationLinkRenderer(node, link, display);
+        },
+        renderTag: (tag) => {
+          return this.documentationTagRenderer(node, tag);
+        }
+      });
+    }
+    return void 0;
+  }
+  documentationLinkRenderer(node, name, display) {
+    var _a;
+    const description = (_a = this.findNameInPrecomputedScopes(node, name)) !== null && _a !== void 0 ? _a : this.findNameInGlobalScope(node, name);
+    if (description && description.nameSegment) {
+      const line = description.nameSegment.range.start.line + 1;
+      const character = description.nameSegment.range.start.character + 1;
+      const uri = description.documentUri.with({ fragment: `L${line},${character}` });
+      return `[${display}](${uri.toString()})`;
+    } else {
+      return void 0;
+    }
+  }
+  documentationTagRenderer(_node, _tag) {
+    return void 0;
+  }
+  findNameInPrecomputedScopes(node, name) {
+    const document = getDocument(node);
+    const precomputed = document.precomputedScopes;
+    if (!precomputed) {
+      return void 0;
+    }
+    let currentNode = node;
+    do {
+      const allDescriptions = precomputed.get(currentNode);
+      const description = allDescriptions.find((e) => e.name === name);
+      if (description) {
+        return description;
+      }
+      currentNode = currentNode.$container;
+    } while (currentNode);
+    return void 0;
+  }
+  findNameInGlobalScope(node, name) {
+    const description = this.indexManager.allElements().find((e) => e.name === name);
+    return description;
+  }
+}
+export {
+  JSDocDocumentationProvider
+};