dorian 2.4.0 → 2.5.0

data/vendor/groovy-beautify/dist/cjs/index.js

@@ -0,0 +1,573 @@
+"use strict";
+var B = Object.defineProperty;
+var T = (s, t, e) =>
+  t in s
+    ? B(s, t, { enumerable: !0, configurable: !0, writable: !0, value: e })
+    : (s[t] = e);
+var f = (s, t, e) => (T(s, typeof t != "symbol" ? t + "" : t, e), e);
+class D {
+  constructor(t, e) {
+    f(this, "text");
+    f(this, "textLength");
+    f(this, "textPosition");
+    f(this, "rules");
+    (this.text = t),
+      (this.textLength = t ? t.length : 0),
+      (this.textPosition = 0),
+      (this.rules = e || []);
+  }
+  scan() {
+    return this.textPosition >= this.textLength
+      ? null
+      : this.text[this.textPosition++];
+  }
+  isDone() {
+    return this.textPosition >= this.textLength;
+  }
+  move(t) {
+    this.textPosition += t;
+  }
+  match(t, e, r) {
+    var a;
+    let n;
+    if (e instanceof RegExp) {
+      const i = new RegExp("^(" + e.source + ")", e.flags),
+        l =
+          (a = this.text.substring(this.textPosition).match(i)) == null
+            ? void 0
+            : a[0];
+      l !== void 0 && (n = l);
+    } else if (e instanceof Array)
+      for (const i of e) {
+        const l = this.match(t, i);
+        if (l) {
+          n = l;
+          break;
+        }
+      }
+    else
+      typeof e == "function"
+        ? (n = e(t, this.text.substring(this.textPosition)))
+        : typeof e == "string" &&
+          this.text.substring(this.textPosition).startsWith(e) &&
+          (n = e);
+    if (n && r) {
+      const i = this.text.charAt(this.textPosition - 1),
+        l = this.text.charAt(this.textPosition + n.length);
+      (i.match(/[A-Za-z0-9_]/) || l.match(/[A-Za-z0-9_]/)) && (n = void 0);
+    }
+    return n;
+  }
+  matchStart(t, e) {
+    return this.match(t, e.start, e.wholeword);
+  }
+  matchEnd(t, e) {
+    return this.match(t, e.end, e.wholeword);
+  }
+  matchSkip(t, e) {
+    return this.match(t, e.skip, e.wholeword);
+  }
+  createDefaultTextObject(t) {
+    return { type: "text", start: t };
+  }
+  parse() {
+    var n;
+    const t = { type: "root", start: "" },
+      e = [],
+      r = [t];
+    for (; !this.isDone(); ) {
+      const a = e[e.length - 1],
+        i = r[r.length - 1],
+        l = (n = i.children) == null ? void 0 : n[i.children.length - 1];
+      if (a) {
+        if (a.skip) {
+          const h = this.matchSkip(i, a);
+          if (typeof h == "string") {
+            l && l.type === "text"
+              ? (l.start += h)
+              : (i.children || (i.children = []),
+                i.children.push(this.createDefaultTextObject(h))),
+              this.move(h.length);
+            continue;
+          }
+        }
+        if (a.end) {
+          const h = this.matchEnd(i, a);
+          if (typeof h == "string") {
+            (i.end = h), e.pop(), r.pop(), this.move(h.length);
+            continue;
+          }
+        }
+      }
+      if (!(a != null && a.exclusive)) {
+        const h = this.rules.find((c) => this.matchStart(i, c));
+        if (h) {
+          const c = this.matchStart(i, h);
+          if (typeof c == "string") {
+            const g = { type: h.name, start: c };
+            i.children || (i.children = []),
+              i.children.push(g),
+              h.end && (e.push(h), r.push(g)),
+              this.move(c.length);
+            continue;
+          }
+        }
+      }
+      const w = this.scan();
+      w &&
+        (l && l.type === "text"
+          ? (l.start += w)
+          : (i.children || (i.children = []),
+            i.children.push(this.createDefaultTextObject(w))));
+    }
+    return t;
+  }
+}
+class o {
+  constructor(t, e) {
+    f(this, "name");
+    f(this, "exclusive", !1);
+    f(this, "wholeword", !1);
+    f(this, "start");
+    f(this, "skip");
+    f(this, "end");
+    (this.name = t),
+      (this.exclusive = !!e.exclusive),
+      (this.wholeword = !!e.wholeword),
+      (this.start = e.start),
+      (this.skip = e.skip),
+      (this.end = e.end);
+  }
+}
+var O = [
+  new o("keywordblock", {
+    start: (s, t) => {
+      var i;
+      const e =
+          (i = s.children) == null
+            ? void 0
+            : i.filter((l) => l.type !== "whitespace"),
+        r = e == null ? void 0 : e.at(-1),
+        n = e == null ? void 0 : e.at(-2),
+        a = t.trimStart();
+      if (
+        (r == null ? void 0 : r.type) === "round" &&
+        (n == null ? void 0 : n.type) === "keywords" &&
+        !a.startsWith("{")
+      )
+        return t.substring(0, t.length - a.length);
+    },
+    end: /\n|$|(?=})/,
+  }),
+  new o("blockcomment", { start: "/*", end: "*/", exclusive: !0 }),
+  new o("linecomment", { start: "//", end: /(?=\n)/, exclusive: !0 }),
+  new o("multilinestring", { start: "'''", end: "'''", exclusive: !0 }),
+  new o("multilinestring", { start: '"""', end: '"""', exclusive: !0 }),
+  new o("string", { start: '"', end: '"', skip: '\\"', exclusive: !0 }),
+  new o("string", { start: "'", end: "'", skip: "\\'", exclusive: !0 }),
+  new o("regexp", { start: /\//g, end: /\//g, skip: /'/g, exclusive: !0 }),
+  new o("numeric", { start: /0[xX][0-9a-fA-F]+\b/g }),
+  new o("numeric", { start: /[+-]?\d+(?:(?:\.\d*)?(?:[eE][+-]?\d+)?)?\b/g }),
+  new o("boolean", { start: /(?:true|false)\b/g }),
+  new o("block", { start: "{", end: "}" }),
+  new o("square", { start: ["?[", "["], end: "]" }),
+  new o("round", { start: "(", end: ")" }),
+  new o("dot", { start: /((\?|\*|&)+)?\.(?=[^\d])(\*)?/g }),
+  new o("delimiters", { start: [",", ":", ";"] }),
+  new o("incdec", { start: ["--", "++", "**"] }),
+  new o("operators", {
+    start: [
+      "--",
+      "-=",
+      "->",
+      "-",
+      "::",
+      "!==",
+      "!=",
+      "?:",
+      "?=",
+      "?",
+      "..<",
+      "..",
+      "**=",
+      "**",
+      "*=",
+      "*",
+      "/=",
+      "/",
+      "&&",
+      "&=",
+      "&",
+      "%=",
+      "%",
+      "^=",
+      "^",
+      "++",
+      "+=",
+      "+",
+      "<..<",
+      "<..",
+      "<<=",
+      "<<",
+      "<=>",
+      "<=",
+      "<",
+      "===",
+      "==~",
+      "==",
+      "=~",
+      "=",
+      ">=",
+      ">>=",
+      ">>>=",
+      ">>",
+      ">",
+      "|=",
+      "||",
+      "|",
+      "~",
+    ],
+  }),
+  new o("negation", { start: "!" }),
+  new o("keywords", {
+    start: [
+      "abstract",
+      "assert",
+      "boolean",
+      "break",
+      "byte",
+      "case",
+      "catch",
+      "char",
+      "class",
+      "continue",
+      "default",
+      "def",
+      "double",
+      "do",
+      "else",
+      "enum",
+      "extends",
+      "finally",
+      "final",
+      "float",
+      "for",
+      "goto",
+      "if",
+      "implements",
+      "import",
+      "instanceof",
+      "interface",
+      "int",
+      "long",
+      "native",
+      "new",
+      "package",
+      "private",
+      "protected",
+      "public",
+      "return",
+      "short",
+      "static",
+      "strictfp",
+      "super",
+      "switch",
+      "synchronized",
+      "throws",
+      "throw",
+      "transient",
+      "try",
+      "void",
+      "volatile",
+      "while",
+      "with",
+    ],
+    wholeword: !0,
+  }),
+  new o("identifiers", { start: /[a-zA-Z_$][a-zA-Z0-9_$]*\b/g, wholeword: !0 }),
+  new o("whitespace", { start: /\s+/g }),
+];
+class W {
+  constructor(t, e) {
+    f(this, "rules");
+    f(this, "options");
+    (this.rules = (t == null ? void 0 : t.map((r) => new r(this))) || []),
+      (this.options = e || { width: 80 });
+  }
+  format(t, e = 0) {
+    let r = "";
+    if (t) {
+      const n = this.rules.find((a) => a.matches(t));
+      t.start !== void 0 && n && (r += n.formatStart(t, e)),
+        n && (r += n.formatChildren(t, e)),
+        t.end !== void 0 && n && (r += n.formatEnd(t, e));
+    }
+    return r;
+  }
+}
+function x(s, t) {
+  return "".padStart(t * 4) + s;
+}
+function R(s, t) {
+  return s + "".padStart(t * 4);
+}
+function L(s) {
+  return s.replace(/^( |\t)+/, "");
+}
+function m(s) {
+  return s.replace(/( |\t)+$/, "");
+}
+class p {
+  constructor(t) {
+    f(this, "formatter");
+    this.formatter = t;
+  }
+  matches(t, e) {
+    return !0;
+  }
+  afterSelf(t, e) {
+    return t;
+  }
+  beforeSelf(t, e, r) {
+    return t;
+  }
+  beforeChild(t, e) {
+    return t;
+  }
+  formatStart(t, e) {
+    var r;
+    return (r = t.start) != null ? r : "";
+  }
+  formatEnd(t, e) {
+    var r;
+    return (r = t.end) != null ? r : "";
+  }
+  allowBreak(t) {
+    return !1;
+  }
+  formatChildren(t, e) {
+    var r;
+    return (
+      ((r = t == null ? void 0 : t.children) == null
+        ? void 0
+        : r.reduce((n, a, i, l) => {
+            var y, k, S, v;
+            const w = this.formatter.rules.find((d) => d.matches(a)),
+              h = this.formatter.rules.find((d) => d.matches(t)),
+              c = this.formatter.rules.find((d) => d.matches(l[i - 1])),
+              g = this.formatter.rules.find((d) => d.matches(l[i + 1]));
+            let u = this.formatter.format(a, e);
+            if (
+              (c && (u = c.afterSelf(u, e)), h && (u = h.beforeChild(u, e)), g)
+            ) {
+              const C =
+                !m(n + u).length ||
+                m(n + u).endsWith(`
+`);
+              u = g.beforeSelf(u, e, C);
+            }
+            const F =
+                (k =
+                  (y = n
+                    .split(
+                      `
+`,
+                    )
+                    .at(-1)) == null
+                    ? void 0
+                    : y.length) != null
+                  ? k
+                  : 0,
+              A =
+                (v =
+                  (S = u
+                    .split(
+                      `
+`,
+                    )
+                    .at(0)) == null
+                    ? void 0
+                    : S.length) != null
+                  ? v
+                  : 0;
+            return (
+              F + A > this.formatter.options.width &&
+                (w == null ? void 0 : w.allowBreak(a)) &&
+                ((u =
+                  `
+` + u.trimStart()),
+                h && (u = h.beforeChild(u, e + 1))),
+              (n += u),
+              n
+            );
+          }, "")) || ""
+    );
+  }
+}
+class z extends p {
+  matches(t) {
+    return (t == null ? void 0 : t.type) === "root";
+  }
+  beforeChild(t) {
+    let e = t;
+    const r = m(e);
+    return (
+      r.endsWith(`
+`) && (e = r),
+      e
+    );
+  }
+}
+class P extends p {
+  beforeChild(t, e) {
+    let r = t;
+    const n = L(r);
+    n.startsWith(`
+`) &&
+      (r =
+        `
+` + x(n.trimStart(), e));
+    const a = m(r);
+    return (
+      a.endsWith(`
+`) && (r = R(a, e)),
+      r
+    );
+  }
+}
+class E extends P {
+  matches(t) {
+    return (t == null ? void 0 : t.type) === "block";
+  }
+  beforeSelf(t, e, r) {
+    return r ? t : t.trimEnd() + " ";
+  }
+  formatEnd(t, e) {
+    return t.end ? x(t.end, e) : "";
+  }
+  formatChildren(t, e) {
+    let r = super.formatChildren(t, e + 1);
+    return (
+      (r = r.trim()),
+      `
+` +
+        x(r, e + 1) +
+        `
+`
+    );
+  }
+}
+class Z extends E {
+  matches(t) {
+    return (t == null ? void 0 : t.type) === "keywordblock";
+  }
+  formatStart() {
+    return "{";
+  }
+  formatEnd(t, e) {
+    return x(
+      `}
+`,
+      e,
+    );
+  }
+}
+class _ extends P {
+  matches(t) {
+    return (
+      (t == null ? void 0 : t.type) === "round" ||
+      (t == null ? void 0 : t.type) === "square"
+    );
+  }
+  isMultiline(t) {
+    var e;
+    return (e = t.children) == null
+      ? void 0
+      : e.some((r) => {
+          var n;
+          return (n = r.start) == null
+            ? void 0
+            : n.includes(`
+`);
+        });
+  }
+  beforeSelf(t, e, r) {
+    return r ? m(t) : t;
+  }
+  formatEnd(t, e) {
+    var r;
+    return this.isMultiline(t)
+      ? t.end
+        ? x(t.end, e)
+        : ""
+      : (r = t.end) != null
+        ? r
+        : "";
+  }
+  formatChildren(t, e) {
+    if (this.isMultiline(t)) {
+      let r = super.formatChildren(t, e + 1);
+      return (
+        (r = r.trim()),
+        `
+` +
+          x(r, e + 1) +
+          `
+`
+      );
+    } else return super.formatChildren(t, e).trim();
+  }
+}
+class $ extends p {
+  matches(t) {
+    return (t == null ? void 0 : t.type) === "dot";
+  }
+  beforeSelf(t, e, r) {
+    return r ? R(m(t), e + 1) : t;
+  }
+}
+class b extends p {
+  matches(t) {
+    return (t == null ? void 0 : t.type) === "operators";
+  }
+  beforeSelf(t) {
+    return m(t) + " ";
+  }
+  afterSelf(t) {
+    return " " + t.trimStart();
+  }
+  allowBreak() {
+    return !0;
+  }
+}
+class M extends p {
+  matches(t) {
+    return (t == null ? void 0 : t.type) === "delimiters";
+  }
+  beforeSelf(t) {
+    return m(t);
+  }
+  afterSelf(t) {
+    return " " + L(t);
+  }
+}
+class q extends p {
+  matches(t) {
+    return (t == null ? void 0 : t.type) === "keywords";
+  }
+  beforeSelf(t, e, r) {
+    return r ? t : t.trimEnd() + " ";
+  }
+  afterSelf(t) {
+    return " " + t.trimStart();
+  }
+  allowBreak() {
+    return !0;
+  }
+}
+var G = [z, E, Z, _, $, q, b, M, p];
+function K(s, t) {
+  const r = new D(s, O).parse();
+  return new W(G, t).format(r);
+}
+module.exports = K;

data/vendor/groovy-beautify/dist/cjs/package.json

@@ -0,0 +1,3 @@
+{
+  "type": "commonjs"
+}