@code0-tech/pictor 0.0.0-mvp.40 → 0.0.0-mvp.42

package/dist/node_modules/@lezer/highlight/dist/index.js

@@ -1,11 +1,11 @@
-import { NodeProp as q } from "../../common/dist/index.js";
-let B = 0;
-class d {
+import { NodeProp as q } from "@lezer/common";
+let A = 0;
+class l {
   /**
   @internal
   */
-  constructor(t, a, n, i) {
-    this.name = t, this.set = a, this.base = n, this.modified = i, this.id = B++;
+  constructor(t, a, i, n) {
+    this.name = t, this.set = a, this.base = i, this.modified = n, this.id = A++;
   }
   toString() {
     let { name: t } = this;
@@ -14,14 +14,14 @@ class d {
     return t;
   }
   static define(t, a) {
-    let n = typeof t == "string" ? t : "?";
-    if (t instanceof d && (a = t), a?.base)
+    let i = typeof t == "string" ? t : "?";
+    if (t instanceof l && (a = t), a?.base)
       throw new Error("Can not derive from a modified tag");
-    let i = new d(n, [], null, []);
-    if (i.set.push(i), a)
-      for (let s of a.set)
-        i.set.push(s);
-    return i;
+    let n = new l(i, [], null, []);
+    if (n.set.push(n), a)
+      for (let r of a.set)
+        n.set.push(r);
+    return n;
   }
   /**
   Define a tag _modifier_, which is a function that, given a tag,
@@ -36,93 +36,57 @@ class d {
   `m1(m3(t1)`, and so on.
   */
   static defineModifier(t) {
-    let a = new M(t);
-    return (n) => n.modified.indexOf(a) > -1 ? n : M.get(n.base || n, n.modified.concat(a).sort((i, s) => i.id - s.id));
+    let a = new b(t);
+    return (i) => i.modified.indexOf(a) > -1 ? i : b.get(i.base || i, i.modified.concat(a).sort((n, r) => n.id - r.id));
   }
 }
-let D = 0;
-class M {
+let I = 0;
+class b {
   constructor(t) {
-    this.name = t, this.instances = [], this.id = D++;
+    this.name = t, this.instances = [], this.id = I++;
   }
   static get(t, a) {
     if (!a.length)
       return t;
-    let n = a[0].instances.find((l) => l.base == t && T(a, l.modified));
-    if (n)
-      return n;
-    let i = [], s = new d(t.name, i, t, a);
-    for (let l of a)
-      l.instances.push(s);
-    let c = $(a);
-    for (let l of t.set)
-      if (!l.modified.length)
-        for (let h of c)
-          i.push(M.get(l, h));
-    return s;
+    let i = a[0].instances.find((g) => g.base == t && j(a, g.modified));
+    if (i)
+      return i;
+    let n = [], r = new l(t.name, n, t, a);
+    for (let g of a)
+      g.instances.push(r);
+    let f = B(a);
+    for (let g of t.set)
+      if (!g.modified.length)
+        for (let w of f)
+          n.push(b.get(g, w));
+    return r;
   }
 }
-function T(r, t) {
-  return r.length == t.length && r.every((a, n) => a == t[n]);
+function j(s, t) {
+  return s.length == t.length && s.every((a, i) => a == t[i]);
 }
-function $(r) {
+function B(s) {
   let t = [[]];
-  for (let a = 0; a < r.length; a++)
-    for (let n = 0, i = t.length; n < i; n++)
-      t.push(t[n].concat(r[a]));
-  return t.sort((a, n) => n.length - a.length);
-}
-function V(r) {
-  let t = /* @__PURE__ */ Object.create(null);
-  for (let a in r) {
-    let n = r[a];
-    Array.isArray(n) || (n = [n]);
-    for (let i of a.split(" "))
-      if (i) {
-        let s = [], c = 2, l = i;
-        for (let N = 0; ; ) {
-          if (l == "..." && N > 0 && N + 3 == i.length) {
-            c = 1;
-            break;
-          }
-          let b = /^"(?:[^"\\]|\\.)*?"|[^\/!]+/.exec(l);
-          if (!b)
-            throw new RangeError("Invalid path: " + i);
-          if (s.push(b[0] == "*" ? "" : b[0][0] == '"' ? JSON.parse(b[0]) : b[0]), N += b[0].length, N == i.length)
-            break;
-          let A = i[N++];
-          if (N == i.length && A == "!") {
-            c = 0;
-            break;
-          }
-          if (A != "/")
-            throw new RangeError("Invalid path: " + i);
-          l = i.slice(N);
-        }
-        let h = s.length - 1, k = s[h];
-        if (!k)
-          throw new RangeError("Invalid path: " + i);
-        let j = new C(n, c, h > 0 ? s.slice(0, h) : null);
-        t[k] = j.sort(t[k]);
-      }
-  }
-  return R.add(t);
+  for (let a = 0; a < s.length; a++)
+    for (let i = 0, n = t.length; i < n; i++)
+      t.push(t[i].concat(s[a]));
+  return t.sort((a, i) => i.length - a.length);
 }
-const R = new q({
-  combine(r, t) {
-    let a, n, i;
-    for (; r || t; ) {
-      if (!r || t && r.depth >= t.depth ? (i = t, t = t.next) : (i = r, r = r.next), a && a.mode == i.mode && !i.context && !a.context)
+const D = new q({
+  combine(s, t) {
+    let a, i, n;
+    for (; s || t; ) {
+      if (!s || t && s.depth >= t.depth ? (n = t, t = t.next) : (n = s, s = s.next), a && a.mode == n.mode && !n.context && !a.context)
         continue;
-      let s = new C(i.tags, i.mode, i.context);
-      a ? a.next = s : n = s, a = s;
+      let r = new O(n.tags, n.mode, n.context);
+      a ? a.next = r : i = r, a = r;
     }
-    return n;
+    return i;
   }
 });
-class C {
-  constructor(t, a, n, i) {
-    this.tags = t, this.mode = a, this.context = n, this.next = i;
+class O {
+  constructor(t, a, i, n) {
+    this.tags = t, this.mode = a, this.context = i, this.next = n;
   }
   get opaque() {
     return this.mode == 0;
@@ -137,55 +101,55 @@ class C {
     return this.context ? this.context.length : 0;
   }
 }
-C.empty = new C([], 2, null);
-function H(r, t) {
+O.empty = new O([], 2, null);
+function $(s, t) {
   let a = /* @__PURE__ */ Object.create(null);
-  for (let s of r)
-    if (!Array.isArray(s.tag))
-      a[s.tag.id] = s.class;
+  for (let r of s)
+    if (!Array.isArray(r.tag))
+      a[r.tag.id] = r.class;
     else
-      for (let c of s.tag)
-        a[c.id] = s.class;
-  let { scope: n, all: i = null } = {};
+      for (let f of r.tag)
+        a[f.id] = r.class;
+  let { scope: i, all: n = null } = {};
   return {
-    style: (s) => {
-      let c = i;
-      for (let l of s)
-        for (let h of l.set) {
-          let k = a[h.id];
-          if (k) {
-            c = c ? c + " " + k : k;
+    style: (r) => {
+      let f = n;
+      for (let g of r)
+        for (let w of g.set) {
+          let v = a[w.id];
+          if (v) {
+            f = f ? f + " " + v : v;
             break;
           }
         }
-      return c;
+      return f;
     },
-    scope: n
+    scope: i
   };
 }
-function z(r) {
-  let t = r.type.prop(R);
-  for (; t && t.context && !r.matchContext(t.context); )
+function H(s) {
+  let t = s.type.prop(D);
+  for (; t && t.context && !s.matchContext(t.context); )
     t = t.next;
   return t || null;
 }
-const e = d.define, x = e(), p = e(), E = e(p), K = e(p), u = e(), v = e(u), I = e(u), m = e(), y = e(m), f = e(), g = e(), S = e(), w = e(S), O = e(), o = {
+const e = l.define, N = e(), p = e(), S = e(p), K = e(p), u = e(), y = e(u), M = e(u), m = e(), h = e(m), c = e(), d = e(), C = e(), k = e(C), x = e(), o = {
   /**
   A comment.
   */
-  comment: x,
+  comment: N,
   /**
   A line [comment](#highlight.tags.comment).
   */
-  lineComment: e(x),
+  lineComment: e(N),
   /**
   A block [comment](#highlight.tags.comment).
   */
-  blockComment: e(x),
+  blockComment: e(N),
   /**
   A documentation [comment](#highlight.tags.comment).
   */
-  docComment: e(x),
+  docComment: e(N),
   /**
   Any kind of identifier.
   */
@@ -197,11 +161,11 @@ const e = d.define, x = e(), p = e(), E = e(p), K = e(p), u = e(), v = e(u), I =
   /**
   A type [name](#highlight.tags.name).
   */
-  typeName: E,
+  typeName: S,
   /**
   A tag name (subtag of [`typeName`](#highlight.tags.typeName)).
   */
-  tagName: e(E),
+  tagName: e(S),
   /**
   A property or field [name](#highlight.tags.name).
   */
@@ -233,31 +197,31 @@ const e = d.define, x = e(), p = e(), E = e(p), K = e(p), u = e(), v = e(u), I =
   /**
   A string [literal](#highlight.tags.literal).
   */
-  string: v,
+  string: y,
   /**
   A documentation [string](#highlight.tags.string).
   */
-  docString: e(v),
+  docString: e(y),
   /**
   A character literal (subtag of [string](#highlight.tags.string)).
   */
-  character: e(v),
+  character: e(y),
   /**
   An attribute value (subtag of [string](#highlight.tags.string)).
   */
-  attributeValue: e(v),
+  attributeValue: e(y),
   /**
   A number [literal](#highlight.tags.literal).
   */
-  number: I,
+  number: M,
   /**
   An integer [number](#highlight.tags.number) literal.
   */
-  integer: e(I),
+  integer: e(M),
   /**
   A floating-point [number](#highlight.tags.number) literal.
   */
-  float: e(I),
+  float: e(M),
   /**
   A boolean [literal](#highlight.tags.literal).
   */
@@ -282,118 +246,118 @@ const e = d.define, x = e(), p = e(), E = e(p), K = e(p), u = e(), v = e(u), I =
   /**
   A language keyword.
   */
-  keyword: f,
+  keyword: c,
   /**
   The [keyword](#highlight.tags.keyword) for the self or this
   object.
   */
-  self: e(f),
+  self: e(c),
   /**
   The [keyword](#highlight.tags.keyword) for null.
   */
-  null: e(f),
+  null: e(c),
   /**
   A [keyword](#highlight.tags.keyword) denoting some atomic value.
   */
-  atom: e(f),
+  atom: e(c),
   /**
   A [keyword](#highlight.tags.keyword) that represents a unit.
   */
-  unit: e(f),
+  unit: e(c),
   /**
   A modifier [keyword](#highlight.tags.keyword).
   */
-  modifier: e(f),
+  modifier: e(c),
   /**
   A [keyword](#highlight.tags.keyword) that acts as an operator.
   */
-  operatorKeyword: e(f),
+  operatorKeyword: e(c),
   /**
   A control-flow related [keyword](#highlight.tags.keyword).
   */
-  controlKeyword: e(f),
+  controlKeyword: e(c),
   /**
   A [keyword](#highlight.tags.keyword) that defines something.
   */
-  definitionKeyword: e(f),
+  definitionKeyword: e(c),
   /**
   A [keyword](#highlight.tags.keyword) related to defining or
   interfacing with modules.
   */
-  moduleKeyword: e(f),
+  moduleKeyword: e(c),
   /**
   An operator.
   */
-  operator: g,
+  operator: d,
   /**
   An [operator](#highlight.tags.operator) that dereferences something.
   */
-  derefOperator: e(g),
+  derefOperator: e(d),
   /**
   Arithmetic-related [operator](#highlight.tags.operator).
   */
-  arithmeticOperator: e(g),
+  arithmeticOperator: e(d),
   /**
   Logical [operator](#highlight.tags.operator).
   */
-  logicOperator: e(g),
+  logicOperator: e(d),
   /**
   Bit [operator](#highlight.tags.operator).
   */
-  bitwiseOperator: e(g),
+  bitwiseOperator: e(d),
   /**
   Comparison [operator](#highlight.tags.operator).
   */
-  compareOperator: e(g),
+  compareOperator: e(d),
   /**
   [Operator](#highlight.tags.operator) that updates its operand.
   */
-  updateOperator: e(g),
+  updateOperator: e(d),
   /**
   [Operator](#highlight.tags.operator) that defines something.
   */
-  definitionOperator: e(g),
+  definitionOperator: e(d),
   /**
   Type-related [operator](#highlight.tags.operator).
   */
-  typeOperator: e(g),
+  typeOperator: e(d),
   /**
   Control-flow [operator](#highlight.tags.operator).
   */
-  controlOperator: e(g),
+  controlOperator: e(d),
   /**
   Program or markup punctuation.
   */
-  punctuation: S,
+  punctuation: C,
   /**
   [Punctuation](#highlight.tags.punctuation) that separates
   things.
   */
-  separator: e(S),
+  separator: e(C),
   /**
   Bracket-style [punctuation](#highlight.tags.punctuation).
   */
-  bracket: w,
+  bracket: k,
   /**
   Angle [brackets](#highlight.tags.bracket) (usually `<` and `>`
   tokens).
   */
-  angleBracket: e(w),
+  angleBracket: e(k),
   /**
   Square [brackets](#highlight.tags.bracket) (usually `[` and `]`
   tokens).
   */
-  squareBracket: e(w),
+  squareBracket: e(k),
   /**
   Parentheses (usually `(` and `)` tokens). Subtag of
   [bracket](#highlight.tags.bracket).
   */
-  paren: e(w),
+  paren: e(k),
   /**
   Braces (usually `{` and `}` tokens). Subtag of
   [bracket](#highlight.tags.bracket).
   */
-  brace: e(w),
+  brace: e(k),
   /**
   Content, for example plain text in XML or markup documents.
   */
@@ -401,31 +365,31 @@ const e = d.define, x = e(), p = e(), E = e(p), K = e(p), u = e(), v = e(u), I =
   /**
   [Content](#highlight.tags.content) that represents a heading.
   */
-  heading: y,
+  heading: h,
   /**
   A level 1 [heading](#highlight.tags.heading).
   */
-  heading1: e(y),
+  heading1: e(h),
   /**
   A level 2 [heading](#highlight.tags.heading).
   */
-  heading2: e(y),
+  heading2: e(h),
   /**
   A level 3 [heading](#highlight.tags.heading).
   */
-  heading3: e(y),
+  heading3: e(h),
   /**
   A level 4 [heading](#highlight.tags.heading).
   */
-  heading4: e(y),
+  heading4: e(h),
   /**
   A level 5 [heading](#highlight.tags.heading).
   */
-  heading5: e(y),
+  heading5: e(h),
   /**
   A level 6 [heading](#highlight.tags.heading).
   */
-  heading6: e(y),
+  heading6: e(h),
   /**
   A prose [content](#highlight.tags.content) separator (such as a horizontal rule).
   */
@@ -479,52 +443,52 @@ const e = d.define, x = e(), p = e(), E = e(p), K = e(p), u = e(), v = e(u), I =
   /**
   Metadata or meta-instruction.
   */
-  meta: O,
+  meta: x,
   /**
   [Metadata](#highlight.tags.meta) that applies to the entire
   document.
   */
-  documentMeta: e(O),
+  documentMeta: e(x),
   /**
   [Metadata](#highlight.tags.meta) that annotates or adds
   attributes to a given syntactic element.
   */
-  annotation: e(O),
+  annotation: e(x),
   /**
   Processing instruction or preprocessor directive. Subtag of
   [meta](#highlight.tags.meta).
   */
-  processingInstruction: e(O),
+  processingInstruction: e(x),
   /**
   [Modifier](#highlight.Tag^defineModifier) that indicates that a
   given element is being defined. Expected to be used with the
   various [name](#highlight.tags.name) tags.
   */
-  definition: d.defineModifier("definition"),
+  definition: l.defineModifier("definition"),
   /**
   [Modifier](#highlight.Tag^defineModifier) that indicates that
   something is constant. Mostly expected to be used with
   [variable names](#highlight.tags.variableName).
   */
-  constant: d.defineModifier("constant"),
+  constant: l.defineModifier("constant"),
   /**
   [Modifier](#highlight.Tag^defineModifier) used to indicate that
   a [variable](#highlight.tags.variableName) or [property
   name](#highlight.tags.propertyName) is being called or defined
   as a function.
   */
-  function: d.defineModifier("function"),
+  function: l.defineModifier("function"),
   /**
   [Modifier](#highlight.Tag^defineModifier) that can be applied to
   [names](#highlight.tags.name) to indicate that they belong to
   the language's standard environment.
   */
-  standard: d.defineModifier("standard"),
+  standard: l.defineModifier("standard"),
   /**
   [Modifier](#highlight.Tag^defineModifier) that indicates a given
   [names](#highlight.tags.name) is local to some scope.
   */
-  local: d.defineModifier("local"),
+  local: l.defineModifier("local"),
   /**
   A generic variant [modifier](#highlight.Tag^defineModifier) that
   can be used to tag language-specific alternative variants of
@@ -533,13 +497,13 @@ const e = d.define, x = e(), p = e(), E = e(p), K = e(p), u = e(), v = e(u), I =
   [variable name](#highlight.tags.variableName) tags, since those
   come up a lot.
   */
-  special: d.defineModifier("special")
+  special: l.defineModifier("special")
 };
-for (let r in o) {
-  let t = o[r];
-  t instanceof d && (t.name = r);
+for (let s in o) {
+  let t = o[s];
+  t instanceof l && (t.name = s);
 }
-H([
+$([
   { tag: o.link, class: "tok-link" },
   { tag: o.heading, class: "tok-heading" },
   { tag: o.emphasis, class: "tok-emphasis" },
@@ -572,9 +536,8 @@ H([
   { tag: o.punctuation, class: "tok-punctuation" }
 ]);
 export {
-  d as Tag,
-  z as getStyleTags,
-  V as styleTags,
-  H as tagHighlighter,
+  l as Tag,
+  H as getStyleTags,
+  $ as tagHighlighter,
   o as tags
 };

package/dist/utils/generics.d.ts

@@ -1,6 +1,7 @@
 import { FunctionDefinitionView } from '../components/d-flow-function/DFlowFunction.view';
 import { DFlowDataTypeReactiveService } from '../components/d-flow-data-type/DFlowDataType.service';
 import { DataType, DataTypeIdentifier, DataTypeRule, DataTypeRulesConfig, Flow, GenericMapper, NodeParameterValue } from '@code0-tech/sagittarius-graphql-types';
+import { DFlowFunctionReactiveService } from '../components/d-flow-function';
 type GenericMappingResult = Record<string, DataTypeIdentifier>;
 type GenericReplacement = DataTypeIdentifier | GenericMapper;
 export type GenericMap = Map<string, GenericReplacement>;
@@ -11,7 +12,7 @@ export declare const resolveGenericKeyMappings: (parameterType: DataTypeIdentifi
 export declare const replaceGenericKeysInType: (type: DataTypeIdentifier, genericMap: GenericMap) => DataTypeIdentifier;
 export declare const resolveAllGenericKeysInDataTypeObject: (genericObj: DataType, concreteObj: DataType, genericKeys: string[]) => Record<string, GenericReplacement | undefined>;
 export declare const replaceGenericKeysInDataTypeObject: (dataType: DataType, genericMap: GenericMap) => DataType;
-export declare const resolveGenericKeys: (func: FunctionDefinitionView, values: NodeParameterValue[], dataTypeService: DFlowDataTypeReactiveService, flow?: Flow) => GenericMap;
+export declare const resolveGenericKeys: (func: FunctionDefinitionView, values: NodeParameterValue[], dataTypeService: DFlowDataTypeReactiveService, functionService: DFlowFunctionReactiveService, flow?: Flow) => GenericMap;
 export declare function isMatchingDataTypeObject(source: DataType, target: DataType): boolean;
 export declare function isMatchingType(source: DataTypeIdentifier, target: DataTypeIdentifier): boolean;
 export declare const resolveType: (type: DataTypeIdentifier, service: DFlowDataTypeReactiveService) => DataTypeIdentifier;