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

package/dist/node_modules/@codemirror/language/dist/index.js

@@ -1,429 +0,0 @@
-import { Tree as d, NodeProp as N, IterMode as C, TreeFragment as w, Parser as V, NodeType as D } from "../../../@lezer/common/dist/index.js";
-import { EditorState as P, Facet as j, StateEffect as q, StateField as $ } from "../../state/dist/index.js";
-import { ViewPlugin as U, EditorView as z, logException as H, Decoration as O, Direction as B } from "../../view/dist/index.js";
-import { tags as G, styleTags as J } from "../../../@lezer/highlight/dist/index.js";
-var b;
-const k = /* @__PURE__ */ new N(), K = /* @__PURE__ */ new N();
-class c {
-  /**
-  Construct a language object. If you need to invoke this
-  directly, first define a data facet with
-  [`defineLanguageFacet`](https://codemirror.net/6/docs/ref/#language.defineLanguageFacet), and then
-  configure your parser to [attach](https://codemirror.net/6/docs/ref/#language.languageDataProp) it
-  to the language's outer syntax node.
-  */
-  constructor(e, t, s = [], r = "") {
-    this.data = e, this.name = r, P.prototype.hasOwnProperty("tree") || Object.defineProperty(P.prototype, "tree", { get() {
-      return A(this);
-    } }), this.parser = t, this.extension = [
-      g.of(this),
-      P.languageData.of((i, a, h) => {
-        let n = I(i, a, h), l = n.type.prop(k);
-        if (!l)
-          return [];
-        let u = i.facet(l), p = n.type.prop(K);
-        if (p) {
-          let y = n.resolve(a - n.from, h);
-          for (let T of p)
-            if (T.test(y, i)) {
-              let L = i.facet(T.facet);
-              return T.type == "replace" ? L : L.concat(u);
-            }
-        }
-        return u;
-      })
-    ].concat(s);
-  }
-  /**
-  Query whether this language is active at the given position.
-  */
-  isActiveAt(e, t, s = -1) {
-    return I(e, t, s).type.prop(k) == this.data;
-  }
-  /**
-  Find the document regions that were parsed using this language.
-  The returned regions will _include_ any nested languages rooted
-  in this language, when those exist.
-  */
-  findRegions(e) {
-    let t = e.facet(g);
-    if (t?.data == this.data)
-      return [{ from: 0, to: e.doc.length }];
-    if (!t || !t.allowsNesting)
-      return [];
-    let s = [], r = (i, a) => {
-      if (i.prop(k) == this.data) {
-        s.push({ from: a, to: a + i.length });
-        return;
-      }
-      let h = i.prop(N.mounted);
-      if (h) {
-        if (h.tree.prop(k) == this.data) {
-          if (h.overlay)
-            for (let n of h.overlay)
-              s.push({ from: n.from + a, to: n.to + a });
-          else
-            s.push({ from: a, to: a + i.length });
-          return;
-        } else if (h.overlay) {
-          let n = s.length;
-          if (r(h.tree, h.overlay[0].from + a), s.length > n)
-            return;
-        }
-      }
-      for (let n = 0; n < i.children.length; n++) {
-        let l = i.children[n];
-        l instanceof d && r(l, i.positions[n] + a);
-      }
-    };
-    return r(A(e), 0), s;
-  }
-  /**
-  Indicates whether this language allows nested languages. The
-  default implementation returns true.
-  */
-  get allowsNesting() {
-    return !0;
-  }
-}
-c.setState = /* @__PURE__ */ q.define();
-function I(o, e, t) {
-  let s = o.facet(g), r = A(o).topNode;
-  if (!s || s.allowsNesting)
-    for (let i = r; i; i = i.enter(e, t, C.ExcludeBuffers | C.EnterBracketed))
-      i.type.isTop && (r = i);
-  return r;
-}
-function A(o) {
-  let e = o.field(c.state, !1);
-  return e ? e.tree : d.empty;
-}
-class Q {
-  /**
-  Create an input object for the given document.
-  */
-  constructor(e) {
-    this.doc = e, this.cursorPos = 0, this.string = "", this.cursor = e.iter();
-  }
-  get length() {
-    return this.doc.length;
-  }
-  syncTo(e) {
-    return this.string = this.cursor.next(e - this.cursorPos).value, this.cursorPos = e + this.string.length, this.cursorPos - this.string.length;
-  }
-  chunk(e) {
-    return this.syncTo(e), this.string;
-  }
-  get lineChunks() {
-    return !0;
-  }
-  read(e, t) {
-    let s = this.cursorPos - this.string.length;
-    return e < s || t >= this.cursorPos ? this.doc.sliceString(e, t) : this.string.slice(e - s, t - s);
-  }
-}
-let m = null;
-class v {
-  constructor(e, t, s = [], r, i, a, h, n) {
-    this.parser = e, this.state = t, this.fragments = s, this.tree = r, this.treeLen = i, this.viewport = a, this.skipped = h, this.scheduleOn = n, this.parse = null, this.tempSkipped = [];
-  }
-  /**
-  @internal
-  */
-  static create(e, t, s) {
-    return new v(e, t, [], d.empty, 0, s, [], null);
-  }
-  startParse() {
-    return this.parser.startParse(new Q(this.state.doc), this.fragments);
-  }
-  /**
-  @internal
-  */
-  work(e, t) {
-    return t != null && t >= this.state.doc.length && (t = void 0), this.tree != d.empty && this.isDone(t ?? this.state.doc.length) ? (this.takeTree(), !0) : this.withContext(() => {
-      var s;
-      if (typeof e == "number") {
-        let r = Date.now() + e;
-        e = () => Date.now() > r;
-      }
-      for (this.parse || (this.parse = this.startParse()), t != null && (this.parse.stoppedAt == null || this.parse.stoppedAt > t) && t < this.state.doc.length && this.parse.stopAt(t); ; ) {
-        let r = this.parse.advance();
-        if (r)
-          if (this.fragments = this.withoutTempSkipped(w.addTree(r, this.fragments, this.parse.stoppedAt != null)), this.treeLen = (s = this.parse.stoppedAt) !== null && s !== void 0 ? s : this.state.doc.length, this.tree = r, this.parse = null, this.treeLen < (t ?? this.state.doc.length))
-            this.parse = this.startParse();
-          else
-            return !0;
-        if (e())
-          return !1;
-      }
-    });
-  }
-  /**
-  @internal
-  */
-  takeTree() {
-    let e, t;
-    this.parse && (e = this.parse.parsedPos) >= this.treeLen && ((this.parse.stoppedAt == null || this.parse.stoppedAt > e) && this.parse.stopAt(e), this.withContext(() => {
-      for (; !(t = this.parse.advance()); )
-        ;
-    }), this.treeLen = e, this.tree = t, this.fragments = this.withoutTempSkipped(w.addTree(this.tree, this.fragments, !0)), this.parse = null);
-  }
-  withContext(e) {
-    let t = m;
-    m = this;
-    try {
-      return e();
-    } finally {
-      m = t;
-    }
-  }
-  withoutTempSkipped(e) {
-    for (let t; t = this.tempSkipped.pop(); )
-      e = E(e, t.from, t.to);
-    return e;
-  }
-  /**
-  @internal
-  */
-  changes(e, t) {
-    let { fragments: s, tree: r, treeLen: i, viewport: a, skipped: h } = this;
-    if (this.takeTree(), !e.empty) {
-      let n = [];
-      if (e.iterChangedRanges((l, u, p, y) => n.push({ fromA: l, toA: u, fromB: p, toB: y })), s = w.applyChanges(s, n), r = d.empty, i = 0, a = { from: e.mapPos(a.from, -1), to: e.mapPos(a.to, 1) }, this.skipped.length) {
-        h = [];
-        for (let l of this.skipped) {
-          let u = e.mapPos(l.from, 1), p = e.mapPos(l.to, -1);
-          u < p && h.push({ from: u, to: p });
-        }
-      }
-    }
-    return new v(this.parser, t, s, r, i, a, h, this.scheduleOn);
-  }
-  /**
-  @internal
-  */
-  updateViewport(e) {
-    if (this.viewport.from == e.from && this.viewport.to == e.to)
-      return !1;
-    this.viewport = e;
-    let t = this.skipped.length;
-    for (let s = 0; s < this.skipped.length; s++) {
-      let { from: r, to: i } = this.skipped[s];
-      r < e.to && i > e.from && (this.fragments = E(this.fragments, r, i), this.skipped.splice(s--, 1));
-    }
-    return this.skipped.length >= t ? !1 : (this.reset(), !0);
-  }
-  /**
-  @internal
-  */
-  reset() {
-    this.parse && (this.takeTree(), this.parse = null);
-  }
-  /**
-  Notify the parse scheduler that the given region was skipped
-  because it wasn't in view, and the parse should be restarted
-  when it comes into view.
-  */
-  skipUntilInView(e, t) {
-    this.skipped.push({ from: e, to: t });
-  }
-  /**
-  Returns a parser intended to be used as placeholder when
-  asynchronously loading a nested parser. It'll skip its input and
-  mark it as not-really-parsed, so that the next update will parse
-  it again.
-  
-  When `until` is given, a reparse will be scheduled when that
-  promise resolves.
-  */
-  static getSkippingParser(e) {
-    return new class extends V {
-      createParse(t, s, r) {
-        let i = r[0].from, a = r[r.length - 1].to;
-        return {
-          parsedPos: i,
-          advance() {
-            let n = m;
-            if (n) {
-              for (let l of r)
-                n.tempSkipped.push(l);
-              e && (n.scheduleOn = n.scheduleOn ? Promise.all([n.scheduleOn, e]) : e);
-            }
-            return this.parsedPos = a, new d(D.none, [], [], a - i);
-          },
-          stoppedAt: null,
-          stopAt() {
-          }
-        };
-      }
-    }();
-  }
-  /**
-  @internal
-  */
-  isDone(e) {
-    e = Math.min(e, this.state.doc.length);
-    let t = this.fragments;
-    return this.treeLen >= e && t.length && t[0].from == 0 && t[0].to >= e;
-  }
-  /**
-  Get the context for the current parse, or `null` if no editor
-  parse is in progress.
-  */
-  static get() {
-    return m;
-  }
-}
-function E(o, e, t) {
-  return w.applyChanges(o, [{ fromA: e, toA: t, fromB: e, toB: t }]);
-}
-class f {
-  constructor(e) {
-    this.context = e, this.tree = e.tree;
-  }
-  apply(e) {
-    if (!e.docChanged && this.tree == this.context.tree)
-      return this;
-    let t = this.context.changes(e.changes, e.state), s = this.context.treeLen == e.startState.doc.length ? void 0 : Math.max(e.changes.mapPos(this.context.treeLen), t.viewport.to);
-    return t.work(20, s) || t.takeTree(), new f(t);
-  }
-  static init(e) {
-    let t = Math.min(3e3, e.doc.length), s = v.create(e.facet(g).parser, e, { from: 0, to: t });
-    return s.work(20, t) || s.takeTree(), new f(s);
-  }
-}
-c.state = /* @__PURE__ */ $.define({
-  create: f.init,
-  update(o, e) {
-    for (let t of e.effects)
-      if (t.is(c.setState))
-        return t.value;
-    return e.startState.facet(g) != e.state.facet(g) ? f.init(e.state) : o.apply(e);
-  }
-});
-let R = (o) => {
-  let e = setTimeout(
-    () => o(),
-    500
-    /* Work.MaxPause */
-  );
-  return () => clearTimeout(e);
-};
-typeof requestIdleCallback < "u" && (R = (o) => {
-  let e = -1, t = setTimeout(
-    () => {
-      e = requestIdleCallback(o, {
-        timeout: 400
-        /* Work.MinPause */
-      });
-    },
-    100
-    /* Work.MinPause */
-  );
-  return () => e < 0 ? clearTimeout(t) : cancelIdleCallback(e);
-});
-const x = typeof navigator < "u" && (!((b = navigator.scheduling) === null || b === void 0) && b.isInputPending) ? () => navigator.scheduling.isInputPending() : null, X = /* @__PURE__ */ U.fromClass(class {
-  constructor(e) {
-    this.view = e, this.working = null, this.workScheduled = 0, this.chunkEnd = -1, this.chunkBudget = -1, this.work = this.work.bind(this), this.scheduleWork();
-  }
-  update(e) {
-    let t = this.view.state.field(c.state).context;
-    (t.updateViewport(e.view.viewport) || this.view.viewport.to > t.treeLen) && this.scheduleWork(), (e.docChanged || e.selectionSet) && (this.view.hasFocus && (this.chunkBudget += 50), this.scheduleWork()), this.checkAsyncSchedule(t);
-  }
-  scheduleWork() {
-    if (this.working)
-      return;
-    let { state: e } = this.view, t = e.field(c.state);
-    (t.tree != t.context.tree || !t.context.isDone(e.doc.length)) && (this.working = R(this.work));
-  }
-  work(e) {
-    this.working = null;
-    let t = Date.now();
-    if (this.chunkEnd < t && (this.chunkEnd < 0 || this.view.hasFocus) && (this.chunkEnd = t + 3e4, this.chunkBudget = 3e3), this.chunkBudget <= 0)
-      return;
-    let { state: s, viewport: { to: r } } = this.view, i = s.field(c.state);
-    if (i.tree == i.context.tree && i.context.isDone(
-      r + 1e5
-      /* Work.MaxParseAhead */
-    ))
-      return;
-    let a = Date.now() + Math.min(this.chunkBudget, 100, e && !x ? Math.max(25, e.timeRemaining() - 5) : 1e9), h = i.context.treeLen < r && s.doc.length > r + 1e3, n = i.context.work(() => x && x() || Date.now() > a, r + (h ? 0 : 1e5));
-    this.chunkBudget -= Date.now() - t, (n || this.chunkBudget <= 0) && (i.context.takeTree(), this.view.dispatch({ effects: c.setState.of(new f(i.context)) })), this.chunkBudget > 0 && !(n && !h) && this.scheduleWork(), this.checkAsyncSchedule(i.context);
-  }
-  checkAsyncSchedule(e) {
-    e.scheduleOn && (this.workScheduled++, e.scheduleOn.then(() => this.scheduleWork()).catch((t) => H(this.view.state, t)).then(() => this.workScheduled--), e.scheduleOn = null);
-  }
-  destroy() {
-    this.working && this.working();
-  }
-  isWorking() {
-    return !!(this.working || this.workScheduled > 0);
-  }
-}, {
-  eventHandlers: { focus() {
-    this.scheduleWork();
-  } }
-}), g = /* @__PURE__ */ j.define({
-  combine(o) {
-    return o.length ? o[0] : null;
-  },
-  enables: (o) => [
-    c.state,
-    X,
-    z.contentAttributes.compute([o], (e) => {
-      let t = e.facet(o);
-      return t && t.name ? { "data-language": t.name } : {};
-    })
-  ]
-}), Y = /* @__PURE__ */ Object.create(null), W = [D.none], F = [], M = /* @__PURE__ */ Object.create(null), Z = /* @__PURE__ */ Object.create(null);
-for (let [o, e] of [
-  ["variable", "variableName"],
-  ["variable-2", "variableName.special"],
-  ["string-2", "string.special"],
-  ["def", "variableName.definition"],
-  ["tag", "tagName"],
-  ["attribute", "attributeName"],
-  ["type", "typeName"],
-  ["builtin", "variableName.standard"],
-  ["qualifier", "modifier"],
-  ["error", "invalid"],
-  ["header", "heading"],
-  ["property", "propertyName"]
-])
-  Z[o] = /* @__PURE__ */ _(Y, e);
-function S(o, e) {
-  F.indexOf(o) > -1 || (F.push(o), console.warn(e));
-}
-function _(o, e) {
-  let t = [];
-  for (let h of e.split(" ")) {
-    let n = [];
-    for (let l of h.split(".")) {
-      let u = o[l] || G[l];
-      u ? typeof u == "function" ? n.length ? n = n.map(u) : S(l, `Modifier ${l} used at start of tag`) : n.length ? S(l, `Tag ${l} used as modifier`) : n = Array.isArray(u) ? u : [u] : S(l, `Unknown highlighting tag ${l}`);
-    }
-    for (let l of n)
-      t.push(l);
-  }
-  if (!t.length)
-    return 0;
-  let s = e.replace(/ /g, "_"), r = s + " " + t.map((h) => h.id), i = M[r];
-  if (i)
-    return i.id;
-  let a = M[r] = D.define({
-    id: W.length,
-    name: s,
-    props: [J({ [s]: t })]
-  });
-  return W.push(a), a.id;
-}
-B.RTL, B.LTR;
-export {
-  Q as DocInput,
-  c as Language,
-  v as ParseContext,
-  g as language,
-  k as languageDataProp,
-  K as sublanguageProp,
-  A as syntaxTree
-};