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

package/dist/node_modules/.pnpm/stylis@4.3.6/node_modules/stylis/src/Enum.mjs

@@ -0,0 +1,16 @@
+var COMMENT = "comm";
+var RULESET = "rule";
+var DECLARATION = "decl";
+var IMPORT = "@import";
+var NAMESPACE = "@namespace";
+var KEYFRAMES = "@keyframes";
+var LAYER = "@layer";
+export {
+  COMMENT,
+  DECLARATION,
+  IMPORT,
+  KEYFRAMES,
+  LAYER,
+  NAMESPACE,
+  RULESET
+};

package/dist/node_modules/.pnpm/stylis@4.3.6/node_modules/stylis/src/Parser.mjs

@@ -0,0 +1,164 @@
+import { DECLARATION, COMMENT, RULESET } from "./Enum.mjs";
+import { strlen, append, charat, replace, substr, indexof, abs, sizeof, trim, from } from "./Utility.mjs";
+import { dealloc, alloc, next, peek, delimit, identifier, commenter, token, escaping, whitespace, node, char, prev, caret } from "./Tokenizer.mjs";
+function compile(value) {
+  return dealloc(parse("", null, null, null, [""], value = alloc(value), 0, [0], value));
+}
+function parse(value, root, parent, rule, rules, rulesets, pseudo, points, declarations) {
+  var index = 0;
+  var offset = 0;
+  var length = pseudo;
+  var atrule = 0;
+  var property = 0;
+  var previous = 0;
+  var variable = 1;
+  var scanning = 1;
+  var ampersand = 1;
+  var character = 0;
+  var type = "";
+  var props = rules;
+  var children = rulesets;
+  var reference = rule;
+  var characters = type;
+  while (scanning)
+    switch (previous = character, character = next()) {
+      // (
+      case 40:
+        if (previous != 108 && charat(characters, length - 1) == 58) {
+          if (indexof(characters += replace(delimit(character), "&", "&\f"), "&\f", abs(index ? points[index - 1] : 0)) != -1)
+            ampersand = -1;
+          break;
+        }
+      // " ' [
+      case 34:
+      case 39:
+      case 91:
+        characters += delimit(character);
+        break;
+      // \t \n \r \s
+      case 9:
+      case 10:
+      case 13:
+      case 32:
+        characters += whitespace(previous);
+        break;
+      // \
+      case 92:
+        characters += escaping(caret() - 1, 7);
+        continue;
+      // /
+      case 47:
+        switch (peek()) {
+          case 42:
+          case 47:
+            append(comment(commenter(next(), caret()), root, parent, declarations), declarations);
+            if ((token(previous || 1) == 5 || token(peek() || 1) == 5) && strlen(characters) && substr(characters, -1, void 0) !== " ") characters += " ";
+            break;
+          default:
+            characters += "/";
+        }
+        break;
+      // {
+      case 123 * variable:
+        points[index++] = strlen(characters) * ampersand;
+      // } ; \0
+      case 125 * variable:
+      case 59:
+      case 0:
+        switch (character) {
+          // \0 }
+          case 0:
+          case 125:
+            scanning = 0;
+          // ;
+          case 59 + offset:
+            if (ampersand == -1) characters = replace(characters, /\f/g, "");
+            if (property > 0 && (strlen(characters) - length || variable === 0 && previous === 47))
+              append(property > 32 ? declaration(characters + ";", rule, parent, length - 1, declarations) : declaration(replace(characters, " ", "") + ";", rule, parent, length - 2, declarations), declarations);
+            break;
+          // @ ;
+          case 59:
+            characters += ";";
+          // { rule/at-rule
+          default:
+            append(reference = ruleset(characters, root, parent, index, offset, rules, points, type, props = [], children = [], length, rulesets), rulesets);
+            if (character === 123)
+              if (offset === 0)
+                parse(characters, root, reference, reference, props, rulesets, length, points, children);
+              else {
+                switch (atrule) {
+                  // c(ontainer)
+                  case 99:
+                    if (charat(characters, 3) === 110) break;
+                  // l(ayer)
+                  case 108:
+                    if (charat(characters, 2) === 97) break;
+                  default:
+                    offset = 0;
+                  // d(ocument) m(edia) s(upports)
+                  case 100:
+                  case 109:
+                  case 115:
+                }
+                if (offset) parse(value, reference, reference, rule && append(ruleset(value, reference, reference, 0, 0, rules, points, type, rules, props = [], length, children), children), rules, children, length, points, rule ? props : children);
+                else parse(characters, reference, reference, reference, [""], children, 0, points, children);
+              }
+        }
+        index = offset = property = 0, variable = ampersand = 1, type = characters = "", length = pseudo;
+        break;
+      // :
+      case 58:
+        length = 1 + strlen(characters), property = previous;
+      default:
+        if (variable < 1) {
+          if (character == 123)
+            --variable;
+          else if (character == 125 && variable++ == 0 && prev() == 125)
+            continue;
+        }
+        switch (characters += from(character), character * variable) {
+          // &
+          case 38:
+            ampersand = offset > 0 ? 1 : (characters += "\f", -1);
+            break;
+          // ,
+          case 44:
+            points[index++] = (strlen(characters) - 1) * ampersand, ampersand = 1;
+            break;
+          // @
+          case 64:
+            if (peek() === 45)
+              characters += delimit(next());
+            atrule = peek(), offset = length = strlen(type = characters += identifier(caret())), character++;
+            break;
+          // -
+          case 45:
+            if (previous === 45 && strlen(characters) == 2)
+              variable = 0;
+        }
+    }
+  return rulesets;
+}
+function ruleset(value, root, parent, index, offset, rules, points, type, props, children, length, siblings) {
+  var post = offset - 1;
+  var rule = offset === 0 ? rules : [""];
+  var size = sizeof(rule);
+  for (var i = 0, j = 0, k = 0; i < index; ++i)
+    for (var x = 0, y = substr(value, post + 1, post = abs(j = points[i])), z = value; x < size; ++x)
+      if (z = trim(j > 0 ? rule[x] + " " + y : replace(y, /&\f/g, rule[x])))
+        props[k++] = z;
+  return node(value, root, parent, offset === 0 ? RULESET : type, props, children, length, siblings);
+}
+function comment(value, root, parent, siblings) {
+  return node(value, root, parent, COMMENT, from(char()), substr(value, 2, -2), 0, siblings);
+}
+function declaration(value, root, parent, length, siblings) {
+  return node(value, root, parent, DECLARATION, substr(value, 0, length), substr(value, length + 1, -1), length, siblings);
+}
+export {
+  comment,
+  compile,
+  declaration,
+  parse,
+  ruleset
+};

package/dist/node_modules/.pnpm/stylis@4.3.6/node_modules/stylis/src/Serializer.mjs

@@ -0,0 +1,29 @@
+import { RULESET, KEYFRAMES, COMMENT, DECLARATION, NAMESPACE, IMPORT, LAYER } from "./Enum.mjs";
+import { strlen } from "./Utility.mjs";
+function serialize(children, callback) {
+  var output = "";
+  for (var i = 0; i < children.length; i++)
+    output += callback(children[i], i, children, callback) || "";
+  return output;
+}
+function stringify(element, index, children, callback) {
+  switch (element.type) {
+    case LAYER:
+      if (element.children.length) break;
+    case IMPORT:
+    case NAMESPACE:
+    case DECLARATION:
+      return element.return = element.return || element.value;
+    case COMMENT:
+      return "";
+    case KEYFRAMES:
+      return element.return = element.value + "{" + serialize(element.children, callback) + "}";
+    case RULESET:
+      if (!strlen(element.value = element.props.join(","))) return "";
+  }
+  return strlen(children = serialize(element.children, callback)) ? element.return = element.value + "{" + children + "}" : "";
+}
+export {
+  serialize,
+  stringify
+};

package/dist/node_modules/.pnpm/stylis@4.3.6/node_modules/stylis/src/Tokenizer.mjs

@@ -0,0 +1,156 @@
+import { strlen, charat, trim, from, substr } from "./Utility.mjs";
+var line = 1;
+var column = 1;
+var length = 0;
+var position = 0;
+var character = 0;
+var characters = "";
+function node(value, root, parent, type, props, children, length2, siblings) {
+  return { value, root, parent, type, props, children, line, column, length: length2, return: "", siblings };
+}
+function char() {
+  return character;
+}
+function prev() {
+  character = position > 0 ? charat(characters, --position) : 0;
+  if (column--, character === 10)
+    column = 1, line--;
+  return character;
+}
+function next() {
+  character = position < length ? charat(characters, position++) : 0;
+  if (column++, character === 10)
+    column = 1, line++;
+  return character;
+}
+function peek() {
+  return charat(characters, position);
+}
+function caret() {
+  return position;
+}
+function slice(begin, end) {
+  return substr(characters, begin, end);
+}
+function token(type) {
+  switch (type) {
+    // \0 \t \n \r \s whitespace token
+    case 0:
+    case 9:
+    case 10:
+    case 13:
+    case 32:
+      return 5;
+    // ! + , / > @ ~ isolate token
+    case 33:
+    case 43:
+    case 44:
+    case 47:
+    case 62:
+    case 64:
+    case 126:
+    // ; { } breakpoint token
+    case 59:
+    case 123:
+    case 125:
+      return 4;
+    // : accompanied token
+    case 58:
+      return 3;
+    // " ' ( [ opening delimit token
+    case 34:
+    case 39:
+    case 40:
+    case 91:
+      return 2;
+    // ) ] closing delimit token
+    case 41:
+    case 93:
+      return 1;
+  }
+  return 0;
+}
+function alloc(value) {
+  return line = column = 1, length = strlen(characters = value), position = 0, [];
+}
+function dealloc(value) {
+  return characters = "", value;
+}
+function delimit(type) {
+  return trim(slice(position - 1, delimiter(type === 91 ? type + 2 : type === 40 ? type + 1 : type)));
+}
+function whitespace(type) {
+  while (character = peek())
+    if (character < 33)
+      next();
+    else
+      break;
+  return token(type) > 2 || token(character) > 3 ? "" : " ";
+}
+function escaping(index, count) {
+  while (--count && next())
+    if (character < 48 || character > 102 || character > 57 && character < 65 || character > 70 && character < 97)
+      break;
+  return slice(index, caret() + (count < 6 && peek() == 32 && next() == 32));
+}
+function delimiter(type) {
+  while (next())
+    switch (character) {
+      // ] ) " '
+      case type:
+        return position;
+      // " '
+      case 34:
+      case 39:
+        if (type !== 34 && type !== 39)
+          delimiter(character);
+        break;
+      // (
+      case 40:
+        if (type === 41)
+          delimiter(type);
+        break;
+      // \
+      case 92:
+        next();
+        break;
+    }
+  return position;
+}
+function commenter(type, index) {
+  while (next())
+    if (type + character === 47 + 10)
+      break;
+    else if (type + character === 42 + 42 && peek() === 47)
+      break;
+  return "/*" + slice(index, position - 1) + "*" + from(type === 47 ? type : next());
+}
+function identifier(index) {
+  while (!token(peek()))
+    next();
+  return slice(index, position);
+}
+export {
+  alloc,
+  caret,
+  char,
+  character,
+  characters,
+  column,
+  commenter,
+  dealloc,
+  delimit,
+  delimiter,
+  escaping,
+  identifier,
+  length,
+  line,
+  next,
+  node,
+  peek,
+  position,
+  prev,
+  slice,
+  token,
+  whitespace
+};

package/dist/node_modules/.pnpm/stylis@4.3.6/node_modules/stylis/src/Utility.mjs

@@ -0,0 +1,38 @@
+var abs = Math.abs;
+var from = String.fromCharCode;
+function trim(value) {
+  return value.trim();
+}
+function replace(value, pattern, replacement) {
+  return value.replace(pattern, replacement);
+}
+function indexof(value, search, position) {
+  return value.indexOf(search, position);
+}
+function charat(value, index) {
+  return value.charCodeAt(index) | 0;
+}
+function substr(value, begin, end) {
+  return value.slice(begin, end);
+}
+function strlen(value) {
+  return value.length;
+}
+function sizeof(value) {
+  return value.length;
+}
+function append(value, array) {
+  return array.push(value), value;
+}
+export {
+  abs,
+  append,
+  charat,
+  from,
+  indexof,
+  replace,
+  sizeof,
+  strlen,
+  substr,
+  trim
+};

package/dist/node_modules/.pnpm/ts-dedent@2.2.0/node_modules/ts-dedent/esm/index.mjs

@@ -0,0 +1,42 @@
+function dedent(templ) {
+  var values = [];
+  for (var _i = 1; _i < arguments.length; _i++) {
+    values[_i - 1] = arguments[_i];
+  }
+  var strings = Array.from(typeof templ === "string" ? [templ] : templ);
+  strings[strings.length - 1] = strings[strings.length - 1].replace(/\r?\n([\t ]*)$/, "");
+  var indentLengths = strings.reduce(function(arr, str) {
+    var matches = str.match(/\n([\t ]+|(?!\s).)/g);
+    if (matches) {
+      return arr.concat(matches.map(function(match) {
+        var _a, _b;
+        return (_b = (_a = match.match(/[\t ]/g)) === null || _a === void 0 ? void 0 : _a.length) !== null && _b !== void 0 ? _b : 0;
+      }));
+    }
+    return arr;
+  }, []);
+  if (indentLengths.length) {
+    var pattern_1 = new RegExp("\n[	 ]{" + Math.min.apply(Math, indentLengths) + "}", "g");
+    strings = strings.map(function(str) {
+      return str.replace(pattern_1, "\n");
+    });
+  }
+  strings[0] = strings[0].replace(/^\r?\n/, "");
+  var string = strings[0];
+  values.forEach(function(value, i) {
+    var endentations = string.match(/(?:^|\n)( *)$/);
+    var endentation = endentations ? endentations[1] : "";
+    var indentedValue = value;
+    if (typeof value === "string" && value.includes("\n")) {
+      indentedValue = String(value).split("\n").map(function(str, i2) {
+        return i2 === 0 ? str : "" + endentation + str;
+      }).join("\n");
+    }
+    string += indentedValue + strings[i + 1];
+  });
+  return string;
+}
+export {
+  dedent,
+  dedent as default
+};

package/dist/node_modules/.pnpm/vscode-jsonrpc@8.2.0/node_modules/vscode-jsonrpc/lib/common/cancellation.mjs

@@ -0,0 +1,95 @@
+import { __exports as cancellation } from "../../../../../../../_virtual/cancellation2.mjs";
+import { __require as requireRal } from "./ral.mjs";
+import { __require as requireIs } from "./is.mjs";
+import { __require as requireEvents } from "./events.mjs";
+var hasRequiredCancellation;
+function requireCancellation() {
+  if (hasRequiredCancellation) return cancellation;
+  hasRequiredCancellation = 1;
+  Object.defineProperty(cancellation, "__esModule", { value: true });
+  cancellation.CancellationTokenSource = cancellation.CancellationToken = void 0;
+  const ral_1 = requireRal();
+  const Is = requireIs();
+  const events_1 = requireEvents();
+  var CancellationToken;
+  (function(CancellationToken2) {
+    CancellationToken2.None = Object.freeze({
+      isCancellationRequested: false,
+      onCancellationRequested: events_1.Event.None
+    });
+    CancellationToken2.Cancelled = Object.freeze({
+      isCancellationRequested: true,
+      onCancellationRequested: events_1.Event.None
+    });
+    function is(value) {
+      const candidate = value;
+      return candidate && (candidate === CancellationToken2.None || candidate === CancellationToken2.Cancelled || Is.boolean(candidate.isCancellationRequested) && !!candidate.onCancellationRequested);
+    }
+    CancellationToken2.is = is;
+  })(CancellationToken || (cancellation.CancellationToken = CancellationToken = {}));
+  const shortcutEvent = Object.freeze(function(callback, context) {
+    const handle = (0, ral_1.default)().timer.setTimeout(callback.bind(context), 0);
+    return { dispose() {
+      handle.dispose();
+    } };
+  });
+  class MutableToken {
+    constructor() {
+      this._isCancelled = false;
+    }
+    cancel() {
+      if (!this._isCancelled) {
+        this._isCancelled = true;
+        if (this._emitter) {
+          this._emitter.fire(void 0);
+          this.dispose();
+        }
+      }
+    }
+    get isCancellationRequested() {
+      return this._isCancelled;
+    }
+    get onCancellationRequested() {
+      if (this._isCancelled) {
+        return shortcutEvent;
+      }
+      if (!this._emitter) {
+        this._emitter = new events_1.Emitter();
+      }
+      return this._emitter.event;
+    }
+    dispose() {
+      if (this._emitter) {
+        this._emitter.dispose();
+        this._emitter = void 0;
+      }
+    }
+  }
+  class CancellationTokenSource {
+    get token() {
+      if (!this._token) {
+        this._token = new MutableToken();
+      }
+      return this._token;
+    }
+    cancel() {
+      if (!this._token) {
+        this._token = CancellationToken.Cancelled;
+      } else {
+        this._token.cancel();
+      }
+    }
+    dispose() {
+      if (!this._token) {
+        this._token = CancellationToken.None;
+      } else if (this._token instanceof MutableToken) {
+        this._token.dispose();
+      }
+    }
+  }
+  cancellation.CancellationTokenSource = CancellationTokenSource;
+  return cancellation;
+}
+export {
+  requireCancellation as __require
+};

package/dist/node_modules/.pnpm/vscode-jsonrpc@8.2.0/node_modules/vscode-jsonrpc/lib/common/events.mjs

@@ -0,0 +1,133 @@
+import { __exports as events } from "../../../../../../../_virtual/events2.mjs";
+import { __require as requireRal } from "./ral.mjs";
+var hasRequiredEvents;
+function requireEvents() {
+  if (hasRequiredEvents) return events;
+  hasRequiredEvents = 1;
+  Object.defineProperty(events, "__esModule", { value: true });
+  events.Emitter = events.Event = void 0;
+  const ral_1 = requireRal();
+  var Event;
+  (function(Event2) {
+    const _disposable = { dispose() {
+    } };
+    Event2.None = function() {
+      return _disposable;
+    };
+  })(Event || (events.Event = Event = {}));
+  class CallbackList {
+    add(callback, context = null, bucket) {
+      if (!this._callbacks) {
+        this._callbacks = [];
+        this._contexts = [];
+      }
+      this._callbacks.push(callback);
+      this._contexts.push(context);
+      if (Array.isArray(bucket)) {
+        bucket.push({ dispose: () => this.remove(callback, context) });
+      }
+    }
+    remove(callback, context = null) {
+      if (!this._callbacks) {
+        return;
+      }
+      let foundCallbackWithDifferentContext = false;
+      for (let i = 0, len = this._callbacks.length; i < len; i++) {
+        if (this._callbacks[i] === callback) {
+          if (this._contexts[i] === context) {
+            this._callbacks.splice(i, 1);
+            this._contexts.splice(i, 1);
+            return;
+          } else {
+            foundCallbackWithDifferentContext = true;
+          }
+        }
+      }
+      if (foundCallbackWithDifferentContext) {
+        throw new Error("When adding a listener with a context, you should remove it with the same context");
+      }
+    }
+    invoke(...args) {
+      if (!this._callbacks) {
+        return [];
+      }
+      const ret = [], callbacks = this._callbacks.slice(0), contexts = this._contexts.slice(0);
+      for (let i = 0, len = callbacks.length; i < len; i++) {
+        try {
+          ret.push(callbacks[i].apply(contexts[i], args));
+        } catch (e) {
+          (0, ral_1.default)().console.error(e);
+        }
+      }
+      return ret;
+    }
+    isEmpty() {
+      return !this._callbacks || this._callbacks.length === 0;
+    }
+    dispose() {
+      this._callbacks = void 0;
+      this._contexts = void 0;
+    }
+  }
+  class Emitter {
+    constructor(_options) {
+      this._options = _options;
+    }
+    /**
+     * For the public to allow to subscribe
+     * to events from this Emitter
+     */
+    get event() {
+      if (!this._event) {
+        this._event = (listener, thisArgs, disposables) => {
+          if (!this._callbacks) {
+            this._callbacks = new CallbackList();
+          }
+          if (this._options && this._options.onFirstListenerAdd && this._callbacks.isEmpty()) {
+            this._options.onFirstListenerAdd(this);
+          }
+          this._callbacks.add(listener, thisArgs);
+          const result = {
+            dispose: () => {
+              if (!this._callbacks) {
+                return;
+              }
+              this._callbacks.remove(listener, thisArgs);
+              result.dispose = Emitter._noop;
+              if (this._options && this._options.onLastListenerRemove && this._callbacks.isEmpty()) {
+                this._options.onLastListenerRemove(this);
+              }
+            }
+          };
+          if (Array.isArray(disposables)) {
+            disposables.push(result);
+          }
+          return result;
+        };
+      }
+      return this._event;
+    }
+    /**
+     * To be kept private to fire an event to
+     * subscribers
+     */
+    fire(event) {
+      if (this._callbacks) {
+        this._callbacks.invoke.call(this._callbacks, event);
+      }
+    }
+    dispose() {
+      if (this._callbacks) {
+        this._callbacks.dispose();
+        this._callbacks = void 0;
+      }
+    }
+  }
+  events.Emitter = Emitter;
+  Emitter._noop = function() {
+  };
+  return events;
+}
+export {
+  requireEvents as __require
+};