@pstdio/workbench 0.1.0

package/dist/workbench-core-DFpwi8Lo.js

@@ -0,0 +1,2264 @@
+import { g as C, n as w, o as D, p as x, c as oe, d as ae, b as ie, a as ce } from "./context-key-service-C--cHa0B.js";
+import { f as W, e as N, m as O, c as j, h as _, i as M, j as B, k as J, n as de, o as q, p as le, q as ue, g as $, r as ge } from "./surface-reconcile-DkRf01ro.js";
+import { b as K } from "./workbench-menu-paths-CQVH6z4_.js";
+const me = () => {
+  const e = C({
+    name: "workbench.breadcrumbs",
+    initialState: {
+      items: void 0
+    }
+  });
+  return {
+    store: e,
+    setItems(t) {
+      return e.setState({
+        items: t
+      }, !1, "setBreadcrumbItems"), w(() => {
+        e.getState().items === t && e.setState({
+          items: void 0
+        }, !1, "clearBreadcrumbItems");
+      });
+    },
+    clearItems() {
+      e.getState().items !== void 0 && e.setState({
+        items: void 0
+      }, !1, "clearBreadcrumbItems");
+    },
+    getItems() {
+      return e.getState().items;
+    },
+    onDidChange(t) {
+      const a = e.subscribeSelector((o) => o.items, () => t());
+      return w(a);
+    }
+  };
+}, fe = (e = {}) => {
+  const t = C({
+    name: "workbench.commandPalette",
+    initialState: {
+      open: e.initialOpen ?? !1,
+      view: "main",
+      initialQuery: "",
+      paramsRequest: null
+    }
+  }), a = (o) => {
+    const c = t.getState();
+    c.open === o.open && c.view === o.view && c.initialQuery === o.initialQuery || t.setState({
+      ...c,
+      ...o
+    }, !1, "setCommandPaletteState");
+  };
+  return {
+    store: t,
+    isOpen() {
+      return t.getState().open;
+    },
+    getView() {
+      return t.getState().view;
+    },
+    getInitialQuery() {
+      return t.getState().initialQuery;
+    },
+    getParamsRequest() {
+      return t.getState().paramsRequest;
+    },
+    open(o = {}) {
+      a({
+        open: !0,
+        view: o.view ?? "main",
+        initialQuery: o.initialQuery ?? ""
+      });
+    },
+    close() {
+      a({
+        open: !1,
+        view: "main",
+        initialQuery: ""
+      });
+    },
+    toggle() {
+      a({
+        open: !t.getState().open,
+        view: "main",
+        initialQuery: ""
+      });
+    },
+    requestParams(o) {
+      t.setState({
+        ...t.getState(),
+        paramsRequest: o
+      }, !1, "requestCommandParams");
+    },
+    clearParams() {
+      t.getState().paramsRequest && t.setState({
+        ...t.getState(),
+        paramsRequest: null
+      }, !1, "clearCommandParams");
+    },
+    onDidChange(o) {
+      const c = t.subscribeSelector((r) => r.open, (r) => o(r));
+      return w(c);
+    }
+  };
+}, he = ["activityBar", "sideBar", "main", "panel", "statusBar"], ye = {
+  activityBar: "activityBarFocus",
+  sideBar: "sideBarFocus",
+  main: "mainFocus",
+  panel: "panelFocus",
+  statusBar: "statusBarFocus"
+}, Se = (e) => {
+  const t = C({
+    name: "workbench.focus",
+    initialState: {
+      activeArea: void 0
+    }
+  }), a = e.context.createScope("workbench.focus"), o = (c) => {
+    a.set("workbenchFocus", c !== void 0), a.set("activeWorkbenchFocusArea", c);
+    for (const r of he)
+      a.set(ye[r], r === c);
+  };
+  return o(void 0), {
+    store: t,
+    setActiveArea(c) {
+      t.getState().activeArea !== c && (t.setState({
+        activeArea: c
+      }, !1, "setActiveWorkbenchFocusArea"), o(c));
+    },
+    clearFocus() {
+      t.getState().activeArea !== void 0 && (t.setState({
+        activeArea: void 0
+      }, !1, "clearWorkbenchFocusArea"), o(void 0));
+    },
+    getActiveArea() {
+      return t.getState().activeArea;
+    },
+    onDidChange(c) {
+      const r = t.subscribeSelector((n) => n.activeArea, (n) => c(n));
+      return w(r);
+    }
+  };
+}, pe = 50, V = 20, F = (e, t) => !e || !t || e.kind !== t.kind ? !1 : e.kind === "resource" ? e.resource?.uri === t.resource?.uri : e.kind === "mode" ? e.modeId === t.modeId : e.widgetId === t.widgetId, ve = (e) => W(e.getLayout().areas[N("primary")]), Z = (e) => {
+  const t = Date.now();
+  return {
+    entryId: `history-${t}-${e}`,
+    recordedAt: t
+  };
+}, z = (e, t, a) => ({
+  ...Z(t),
+  kind: e.resource ? "resource" : "widget",
+  modeId: a,
+  resource: e.resource,
+  widgetId: e.resource ? void 0 : e.widgetId,
+  contributionId: e.resource ? void 0 : e.contributionId,
+  title: e.title
+}), be = (e, t, a) => ({
+  ...Z(t),
+  kind: "mode",
+  modeId: a,
+  title: e?.label ?? a
+}), we = (e) => {
+  const t = e.maxEntries ?? pe, a = C({
+    name: "workbench.history",
+    initialState: {
+      entries: [],
+      cursor: -1,
+      recentlyClosed: []
+    }
+  });
+  let o = 0, c = !1, r = !1, n = !1;
+  const l = /* @__PURE__ */ new Set(), y = (d) => {
+    const f = a.getState(), S = f.entries[f.cursor];
+    if (F(S, d)) return;
+    const v = f.entries.slice(0, f.cursor + 1), A = S?.kind === "mode" && d.kind !== "mode" && S.modeId === d.modeId ? [...v.slice(0, -1), d] : [...v, d], E = A.length - t, L = E > 0 ? A.slice(E) : A, T = L.length - 1;
+    a.setState({
+      ...f,
+      entries: L,
+      cursor: T
+    }, !1, "history.record");
+  }, m = (d) => {
+    d.pinned || (o += 1, y(z(d, o, e.modes?.getActiveModeId())));
+  }, g = () => {
+    if (c) return;
+    const d = e.modes?.getActiveModeId();
+    o += 1, y(be(d ? e.modes?.getMode(d) : void 0, o, d));
+  }, s = (d) => {
+    o += 1;
+    const f = z(d, o, e.modes?.getActiveModeId()), S = a.getState(), v = [...S.recentlyClosed.filter((A) => !F(A, f)), f], R = v.length > V ? v.slice(v.length - V) : v;
+    a.setState({
+      ...S,
+      recentlyClosed: R
+    }, !1, "history.recordClosed");
+  }, i = (d = e.layout.getLayout()) => {
+    const f = /* @__PURE__ */ new Map();
+    for (const S of Object.values(d.areas))
+      for (const v of S.widgets) f.set(v.widgetId, v);
+    return f;
+  };
+  let u = i();
+  const h = () => {
+    const d = e.layout.getLayout(), f = i(d);
+    for (const [v, R] of u)
+      !f.has(v) && R.closable && s(R);
+    if (u = f, c) {
+      r = !0;
+      return;
+    }
+    const S = ve(e.layout);
+    S && m(S);
+  };
+  e.layout.store.subscribeSelector((d) => d.layout, () => h()), e.modes?.onDidChangeActive(() => g()), e.resources.onDidOpenResource((d) => {
+    c || l.has(d.uri) || m({
+      widgetId: d.uri,
+      contributionId: d.uri,
+      title: d.label,
+      pinned: !1,
+      resource: d
+    });
+  });
+  const p = (d) => {
+    c = !0, r = !1, n = !1;
+    let f = !1;
+    try {
+      const S = d();
+      if (S && typeof S.finally == "function" && (!r || n)) {
+        f = !0, S.then(() => {
+          c = !1;
+        }, () => {
+          c = !1;
+        });
+        return;
+      }
+    } finally {
+      f || (c = !1);
+    }
+  }, b = (d) => {
+    e.modes && e.modes.getActiveModeId() !== d.modeId && (n = !0, e.modes.setActiveMode(d.modeId));
+  }, I = (d) => {
+    if (b(d), d.kind !== "mode") {
+      if (d.kind === "resource" && d.resource)
+        return l.add(d.resource.uri), e.resources.openResource(d.resource, {
+          replaceActive: !0
+        }).finally(() => {
+          d.resource && l.delete(d.resource.uri);
+        });
+      if (d.kind === "widget" && d.widgetId) {
+        const f = e.layout.getLayout();
+        return Object.values(f.areas).some((v) => v.widgets.some((R) => R.widgetId === d.widgetId)) ? e.layout.activateWidget(d.widgetId) : e.layout.openWidget(d.contributionId ?? d.widgetId);
+      }
+    }
+  }, P = (d) => {
+    const f = a.getState(), S = f.cursor + d, v = f.entries[S];
+    if (v)
+      return a.setState({
+        ...f,
+        cursor: S
+      }, !1, d < 0 ? "history.goBack" : "history.goForward"), p(() => I(v)), v;
+  };
+  return {
+    store: a,
+    goBack() {
+      return P(-1);
+    },
+    goForward() {
+      return P(1);
+    },
+    goPrevious() {
+      const d = a.getState(), f = d.entries[d.cursor];
+      for (let S = d.entries.length - 1; S >= 0; S -= 1) {
+        const v = d.entries[S];
+        if (!F(v, f))
+          return a.setState({
+            ...d,
+            cursor: S
+          }, !1, "history.goPrevious"), p(() => I(v)), v;
+      }
+    },
+    recentlyClosed() {
+      return a.getState().recentlyClosed;
+    },
+    reopenLastClosed() {
+      const d = a.getState(), f = d.recentlyClosed[d.recentlyClosed.length - 1];
+      if (f)
+        return a.setState({
+          ...d,
+          recentlyClosed: d.recentlyClosed.slice(0, -1)
+        }, !1, "history.reopenLastClosed"), p(() => I(f)), f;
+    },
+    clear() {
+      a.setState({
+        entries: [],
+        cursor: -1,
+        recentlyClosed: []
+      }, !1, "history.clear");
+    }
+  };
+}, Ie = (e) => {
+  const t = () => e.persistence?.getLastResource();
+  return {
+    get: t,
+    set: (c) => e.persistence?.setLastResource(c),
+    restore: async () => {
+      const c = t();
+      if (!c) return !1;
+      try {
+        return await e.openResource(c), !0;
+      } catch {
+        return !1;
+      }
+    }
+  };
+}, Re = (e = {}) => {
+  const t = e.persistence?.getPanelStates(), a = C({
+    name: "workbench.panels",
+    initialState: {
+      openByAreaId: t?.openByAreaId ?? {}
+    }
+  }), o = () => {
+    e.persistence && e.persistence.setPanelStates({
+      openByAreaId: a.getState().openByAreaId
+    });
+  }, c = (r) => a.getState().openByAreaId[r] ?? !0;
+  return {
+    store: a,
+    isOpen: c,
+    setOpen(r, n) {
+      const l = a.getState();
+      (l.openByAreaId[r] ?? !0) !== n && (a.setState({
+        openByAreaId: {
+          ...l.openByAreaId,
+          [r]: n
+        }
+      }, !1, "setPanelOpen"), o());
+    },
+    toggle(r) {
+      this.setOpen(r, !c(r));
+    },
+    onDidChange(r) {
+      const n = a.subscribe((l) => r(l));
+      return w(n);
+    }
+  };
+}, Pe = (e = {}) => {
+  const t = C({
+    name: "workbench.sessionPanel",
+    initialState: {
+      mode: e.initialMode ?? "bubble"
+    }
+  });
+  return {
+    store: t,
+    getMode() {
+      return t.getState().mode;
+    },
+    setMode(a) {
+      t.getState().mode !== a && t.setState({
+        mode: a
+      }, !1, "setMode");
+    },
+    onDidChange(a) {
+      const o = t.subscribeSelector((c) => c.mode, (c) => a(c));
+      return w(o);
+    }
+  };
+}, Ce = "Terminal", ke = 200, Ae = () => {
+  const e = C({
+    name: "workbench.terminal",
+    initialState: {
+      sessionsById: {}
+    }
+  });
+  let t = null;
+  const a = /* @__PURE__ */ new Map(), o = /* @__PURE__ */ new Map(), c = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Set(), n = (s, i, u) => {
+    const h = e.getState(), p = h.sessionsById[s];
+    p && e.setState({
+      sessionsById: {
+        ...h.sessionsById,
+        [s]: {
+          ...p,
+          ...i
+        }
+      }
+    }, !1, u);
+  }, l = (s) => {
+    const i = a.get(s);
+    if (!i) throw new Error(`Unknown terminal session: ${s}`);
+    return i;
+  }, y = (s) => {
+    a.delete(s), c.delete(s), r.delete(s);
+    const i = o.get(s) ?? [];
+    o.delete(s);
+    for (const u of i) u();
+  }, m = (s, i) => {
+    if (r.has(s)) return;
+    const u = c.get(s);
+    u && (u.push(i), u.length > ke && u.shift());
+  }, g = async (s) => {
+    await l(s.sessionId).kill(s.signal), n(s.sessionId, {
+      status: "killed"
+    }, "killTerminalSession"), y(s.sessionId);
+  };
+  return {
+    store: e,
+    isAvailable: () => t !== null,
+    setSessionOpener(s) {
+      t = s;
+    },
+    async open(s) {
+      if (!t) throw new Error("Terminal sessions are not available in this workbench host.");
+      const i = await t(s.request);
+      a.set(i.id, i), c.set(i.id, []);
+      const u = [i.onData((b) => m(i.id, b))], h = i.onTitle?.((b) => n(i.id, {
+        title: b
+      }, "terminalSessionTitleChanged"));
+      h && u.push(h), u.push(i.onExit((b) => {
+        e.getState().sessionsById[i.id]?.status === "running" && n(i.id, {
+          status: "exited",
+          exit: b
+        }, "terminalSessionExited"), y(i.id);
+      })), o.set(i.id, u);
+      const p = e.getState();
+      return e.setState({
+        sessionsById: {
+          ...p.sessionsById,
+          [i.id]: {
+            id: i.id,
+            title: s.title ?? Ce,
+            status: "running"
+          }
+        }
+      }, !1, "openTerminalSession"), {
+        sessionId: i.id
+      };
+    },
+    write(s) {
+      l(s.sessionId).write(s.data);
+    },
+    resize(s) {
+      l(s.sessionId).resize(s.cols, s.rows);
+    },
+    kill: g,
+    subscribe(s, i) {
+      const u = l(s), h = [];
+      if (i.onData) {
+        const p = c.get(s) ?? [];
+        c.delete(s), r.add(s), h.push(u.onData(i.onData));
+        for (const b of p) i.onData(b);
+      }
+      return h.push(i.onExit ? u.onExit(i.onExit) : void 0, i.onError ? u.onError(i.onError) : void 0), () => {
+        for (const p of h) p?.();
+      };
+    },
+    getSession(s) {
+      return e.getState().sessionsById[s];
+    },
+    listSessions() {
+      return Object.values(e.getState().sessionsById);
+    },
+    async dispose() {
+      const s = Object.values(e.getState().sessionsById).filter((i) => i.status === "running");
+      await Promise.all(s.map((i) => g({
+        sessionId: i.id
+      })));
+      for (const i of Object.values(e.getState().sessionsById)) y(i.id);
+      a.clear();
+    }
+  };
+}, xe = () => {
+  const e = C({
+    name: "workbench.commandPaletteResources",
+    initialState: {
+      providers: {},
+      refreshToken: 0
+    }
+  });
+  return {
+    store: e,
+    registerProvider(t) {
+      const a = e.getState();
+      if (a.providers[t.id])
+        throw new Error(`Command palette resource provider already registered: ${t.id}`);
+      return e.setState({
+        ...a,
+        providers: {
+          ...a.providers,
+          [t.id]: t
+        }
+      }, !1, "registerProvider"), w(() => {
+        const o = e.getState();
+        if (o.providers[t.id] !== t) return;
+        const {
+          [t.id]: c,
+          ...r
+        } = o.providers;
+        e.setState({
+          ...o,
+          providers: r
+        }, !1, "unregisterProvider");
+      });
+    },
+    listProviders() {
+      return Object.values(e.getState().providers);
+    },
+    async queryProviders(t) {
+      const a = Object.values(e.getState().providers);
+      return Promise.all(a.map(async (o) => {
+        try {
+          const c = await o.query(t);
+          return {
+            providerId: o.id,
+            title: o.title,
+            results: c
+          };
+        } catch {
+          return {
+            providerId: o.id,
+            title: o.title,
+            results: []
+          };
+        }
+      }));
+    },
+    refresh() {
+      const t = e.getState();
+      e.setState({
+        ...t,
+        refreshToken: t.refreshToken + 1
+      }, !1, "refresh");
+    }
+  };
+}, De = (e = {}) => {
+  const t = C({
+    name: "workbench.commands",
+    initialState: {
+      commands: {}
+    }
+  }), a = /* @__PURE__ */ new Set(), o = (r) => {
+    const n = t.getState().commands[r];
+    if (!n) throw new Error(`Command not registered: ${r}`);
+    return n;
+  }, c = (r) => {
+    for (const n of a) n(r);
+  };
+  return {
+    store: t,
+    registerCommand(r, n, l) {
+      const y = t.getState();
+      if (y.commands[r.id]) throw new Error(`Command already registered: ${r.id}`);
+      const m = {
+        ...x(l),
+        command: r,
+        handler: n
+      };
+      return t.setState({
+        commands: {
+          ...y.commands,
+          [r.id]: m
+        }
+      }, !1, "registerCommand"), w(() => {
+        const g = t.getState();
+        if (g.commands[r.id] !== m) return;
+        const {
+          [r.id]: s,
+          ...i
+        } = g.commands;
+        t.setState({
+          commands: i
+        }, !1, "unregisterCommand");
+      });
+    },
+    getCommand(r) {
+      return t.getState().commands[r];
+    },
+    listCommands() {
+      return Object.values(t.getState().commands).sort(D);
+    },
+    isCommandEnabled(r, n) {
+      return o(r).handler.isEnabled?.(n) ?? !0;
+    },
+    isCommandVisible(r, n) {
+      const l = o(r);
+      return e.context?.matches(l.command.when) ? l.handler.isVisible?.(n) ?? !0 : !1;
+    },
+    isCommandToggled(r, n) {
+      return o(r).handler.isToggled?.(n) ?? !1;
+    },
+    async executeCommand(r, n, l) {
+      const y = o(r);
+      if (y.handler.isEnabled?.(n) === !1) {
+        const m = new Error(`Command is disabled: ${r}`);
+        throw c({
+          commandId: r,
+          args: n,
+          error: m
+        }), m;
+      }
+      try {
+        return await y.handler.execute(n, l);
+      } catch (m) {
+        throw c({
+          commandId: r,
+          args: n,
+          error: m
+        }), m;
+      }
+    },
+    onDidExecuteError(r) {
+      return a.add(r), w(() => {
+        a.delete(r);
+      });
+    }
+  };
+}, Be = (e) => {
+  const {
+    getLayout: t,
+    getWidgets: a,
+    getPlaceholder: o
+  } = e;
+  return {
+    getAreaSize(c) {
+      const r = t().areas[c].size, n = W(t().areas[c]), l = n ? a()[n.contributionId]?.areaSize : o(c)?.areaSize;
+      return r === void 0 ? l : {
+        ...l,
+        defaultPx: r
+      };
+    },
+    getAreaCollapsible(c) {
+      const r = W(t().areas[c]);
+      return r ? a()[r.contributionId]?.areaCollapsible ?? !0 : o(c)?.areaCollapsible ?? !0;
+    },
+    getAreaHeaderBorderBottom(c) {
+      const r = W(t().areas[c]);
+      return r ? a()[r.contributionId]?.headerBorderBottom ?? !0 : !0;
+    }
+  };
+}, We = (e) => {
+  const {
+    getPlaceholders: t,
+    getWidgets: a
+  } = e;
+  return {
+    listPlaceholders() {
+      return Object.values(t()).sort(D);
+    },
+    listWidgets() {
+      return Object.values(a()).sort(D);
+    }
+  };
+}, Ee = (e) => {
+  const {
+    store: t,
+    getPlaceholders: a,
+    getWidgets: o,
+    persistLayout: c
+  } = e;
+  return {
+    registerPlaceholder(r, n) {
+      if (a()[r.area])
+        throw new Error(`Placeholder already registered: ${r.area}`);
+      const {
+        priority: y,
+        ...m
+      } = r, g = {
+        ...m,
+        ...x({
+          ...n,
+          priority: n?.priority ?? y
+        })
+      }, s = t.getState();
+      return t.setState({
+        ...s,
+        placeholders: {
+          ...s.placeholders,
+          [r.area]: g
+        }
+      }, !1, "registerPlaceholder"), w(() => {
+        const i = t.getState();
+        if (i.placeholders[r.area] !== g) return;
+        const {
+          [r.area]: u,
+          ...h
+        } = i.placeholders;
+        t.setState({
+          ...i,
+          placeholders: h
+        }, !1, "unregisterPlaceholder");
+      });
+    },
+    registerWidget(r, n) {
+      if (o()[r.id]) throw new Error(`Widget already registered: ${r.id}`);
+      const {
+        priority: y,
+        reuse: m,
+        singleton: g,
+        ...s
+      } = r, i = {
+        ...s,
+        reuse: m ?? "resource",
+        // Panels are singleton by default; widgets opt into tabbed placements
+        // by declaring `singleton: false`.
+        singleton: g ?? !0,
+        ...x({
+          ...n,
+          priority: n?.priority ?? y
+        })
+      }, u = t.getState();
+      return t.setState({
+        ...u,
+        widgets: {
+          ...u.widgets,
+          [r.id]: i
+        }
+      }, !1, "registerWidget"), w(() => {
+        const h = t.getState();
+        if (h.widgets[r.id] !== i) return;
+        const {
+          [r.id]: p,
+          ...b
+        } = h.widgets, I = J(h.layout, r.id);
+        t.setState({
+          widgets: b,
+          layout: I
+        }, !1, "unregisterWidget"), c();
+      });
+    }
+  };
+}, Te = (e, t, a) => {
+  if (e.singleton) return q(t, e.id);
+  if (e.reuse !== "none")
+    return a.resource ? le(t, e.id, a.resource.uri) : q(t, e.id);
+}, Me = (e) => {
+  const {
+    getLayout: t,
+    requireWidget: a,
+    applyAndActivate: o
+  } = e;
+  let c = 0;
+  const r = (g, s, i) => {
+    const u = M(s.placement, g, i), h = B(t(), s.areaId, (p) => p.map((b, I) => I === s.index ? u : b));
+    return o(h, s.areaId, u);
+  }, n = (g, s, i, u, h) => {
+    const p = M(u, g, h), b = B(t(), s, (I) => I.map((P, d) => d === i ? p : P));
+    return o(b, s, p);
+  }, l = (g, s, i, u, h) => {
+    if (s.areaId !== i) {
+      const I = M(s.placement, g, h), P = B(t(), s.areaId, (f) => f.filter((S, v) => v !== s.index), {
+        clearActiveWidget: t().areas[s.areaId].activeWidgetId === s.placement.widgetId
+      }), d = B(P, i, (f) => {
+        if (u < 0) return [...f, I];
+        const S = [...f];
+        return S.splice(u, 1, I), S;
+      });
+      return o(d, i, I);
+    }
+    if (u < 0 || s.index === u)
+      return r(g, s, h);
+    const p = M(s.placement, g, h), b = B(t(), i, (I) => I.map((P, d) => d === s.index ? p : P).filter((P, d) => d !== u));
+    return o(b, i, p);
+  }, y = (g, s, i, u) => {
+    const p = t().areas[s].widgets.some((d, f) => f !== i && d.widgetId === g.id);
+    p && (c += 1);
+    const b = p ? `${g.id}:${c}` : g.id, I = ue(b, g, u), P = B(t(), s, (d) => {
+      if (i >= 0) {
+        const f = [...d];
+        return f.splice(i, 1, I), f;
+      }
+      return [...d, I];
+    });
+    return o(P, s, I);
+  };
+  return {
+    openWidget: (g, s = {}) => {
+      const i = a(g), u = t(), h = s.area ?? i.area ?? i.fallbackArea ?? "main", p = u.areas[h], b = s.replaceActive ? p.widgets.findIndex((d) => d.widgetId === p.activeWidgetId && !d.pinned) : -1, I = b >= 0 ? p.widgets[b] : void 0, P = Te(i, u, s);
+      return P ? l(i, P, h, b, s) : I?.contributionId === i.id ? n(i, h, b, I, s) : y(i, h, b, s);
+    }
+  };
+}, Le = (e = {}) => {
+  let t;
+  const a = /* @__PURE__ */ new Set(), o = e.persistence?.getLayout(t), c = o ? O(o) : j(), r = C({
+    name: "workbench.layout",
+    initialState: {
+      layout: c,
+      widgets: {},
+      placeholders: {}
+    }
+  }), n = () => r.getState().layout, l = () => r.getState().placeholders, y = () => r.getState().widgets, m = (d) => l()[d], g = Be({
+    getLayout: n,
+    getWidgets: y,
+    getPlaceholder: m
+  }), s = We({
+    getPlaceholders: l,
+    getWidgets: y
+  }), i = () => {
+    e.persistence?.setLayout(n(), t);
+  }, u = (d) => {
+    const f = y()[d];
+    if (!f) throw new Error(`Widget not registered: ${d}`);
+    return f;
+  }, h = (d) => {
+    const f = r.getState();
+    f.layout !== d && r.setState({
+      ...f,
+      layout: d
+    }, !1, "setLayout");
+  }, p = (d, f) => {
+    const S = n(), v = S.areas[d], R = f(v);
+    R !== v && (h({
+      ...S,
+      areas: {
+        ...S.areas,
+        [d]: R
+      }
+    }), i());
+  }, b = (d, f, S) => (h(de(d, f, S)), i(), S), I = Ee({
+    store: r,
+    getPlaceholders: l,
+    getWidgets: y,
+    persistLayout: i
+  }), P = Me({
+    getLayout: n,
+    requireWidget: u,
+    applyAndActivate: b
+  });
+  return {
+    store: r,
+    registerPlaceholder: I.registerPlaceholder,
+    registerWidget: I.registerWidget,
+    unregisterWidget(d, f = {}) {
+      const S = r.getState();
+      if (!S.widgets[d]) return;
+      const {
+        [d]: v,
+        ...R
+      } = S.widgets, A = f.removePlacements === !1 ? S.layout : J(S.layout, d);
+      r.setState({
+        ...S,
+        widgets: R,
+        layout: A
+      }, !1, "unregisterWidget"), f.persist !== !1 && i();
+    },
+    getWidget(d) {
+      return y()[d];
+    },
+    getPlaceholder: m,
+    getAreaSize: g.getAreaSize,
+    getAreaCollapsible: g.getAreaCollapsible,
+    getAreaHeaderBorderBottom: g.getAreaHeaderBorderBottom,
+    setAreaVisible(d, f) {
+      p(d, (S) => S.visible === f ? S : {
+        ...S,
+        visible: f
+      });
+    },
+    setAreaSize(d, f) {
+      p(d, (S) => S.size === f ? S : {
+        ...S,
+        size: f
+      });
+    },
+    listPlaceholders: s.listPlaceholders,
+    listWidgets: s.listWidgets,
+    openWidget: P.openWidget,
+    updateWidgetPlacement(d, f) {
+      const S = n();
+      for (const v of Object.values(S.areas)) {
+        const R = v.widgets.findIndex((T) => T.widgetId === d);
+        if (R < 0) continue;
+        const A = u(v.widgets[R].contributionId), E = M(v.widgets[R], A, f), L = B(S, v.id, (T) => T.map((se, ne) => ne === R ? E : se));
+        return h(L), i(), E;
+      }
+      throw new Error(`Widget placement not found: ${d}`);
+    },
+    activateWidget(d) {
+      const f = n();
+      for (const S of Object.values(f.areas)) {
+        const v = S.widgets.find((R) => R.widgetId === d);
+        if (v) return b(f, S.id, v);
+      }
+      throw new Error(`Widget placement not found: ${d}`);
+    },
+    closeWidget(d) {
+      const f = _(n(), d);
+      if (!f) throw new Error(`Widget placement not found: ${d}`);
+      if (f.closedPlacement.closable !== !0) throw new Error(`Widget cannot be closed: ${d}`);
+      return h(f.layout), i(), f.activePlacement;
+    },
+    removeWidgetPlacement(d) {
+      const f = _(n(), d);
+      if (f)
+        return h(f.layout), i(), f.activePlacement;
+    },
+    clearArea(d) {
+      const f = n(), S = f.areas[d], v = S.activeWidgetId, R = {
+        ...f,
+        areas: {
+          ...f.areas,
+          [d]: {
+            ...S,
+            widgets: [],
+            activeWidgetId: void 0
+          }
+        }
+      }, A = v && f.activeWidgetId === v ? {
+        ...R,
+        activeWidgetId: void 0,
+        activeResourceUri: void 0
+      } : R;
+      h(A), i();
+    },
+    resetAreas() {
+      const d = n(), f = {};
+      for (const [S, v] of Object.entries(d.areas))
+        f[S] = {
+          ...v,
+          widgets: [],
+          activeWidgetId: void 0
+        };
+      h({
+        areas: f,
+        activeWidgetId: void 0,
+        activeResourceUri: void 0
+      }), i();
+    },
+    getLayout: n,
+    restoreLayout(d) {
+      h(O(d)), i();
+    },
+    setPersistenceScope(d) {
+      if (t === d) return;
+      e.persistence?.setLayout(n(), t), t = d;
+      const f = e.persistence?.getLayout(t), S = f ? O(f) : j(), v = r.getState();
+      r.setState({
+        ...v,
+        layout: S
+      }, !1, "setPersistenceScope");
+      for (const R of a) R(t);
+    },
+    getPersistenceScope: () => t,
+    onDidChangePersistenceScope(d) {
+      return a.add(d), w(() => a.delete(d));
+    }
+  };
+}, H = (e) => e.join("/"), Oe = (e) => {
+  const t = C({
+    name: "workbench.menus",
+    initialState: {
+      itemsByPath: {}
+    }
+  });
+  return {
+    menuStore: t,
+    registerMenuItem(a, o, c) {
+      if (!e.commands.getCommand(o.commandId)) throw new Error(`Menu command not registered: ${o.commandId}`);
+      const r = H(a), n = {
+        ...x(c),
+        ...o,
+        path: a
+      }, l = t.getState(), y = l.itemsByPath[r] ?? [];
+      return t.setState({
+        itemsByPath: {
+          ...l.itemsByPath,
+          [r]: [...y, n]
+        }
+      }, !1, "registerMenuItem"), w(() => {
+        const m = t.getState(), g = m.itemsByPath[r] ?? [], s = g.filter((i) => i !== n);
+        s.length !== g.length && t.setState({
+          itemsByPath: {
+            ...m.itemsByPath,
+            [r]: s
+          }
+        }, !1, "unregisterMenuItem");
+      });
+    },
+    listMenuItems(a) {
+      return [...t.getState().itemsByPath[H(a)] ?? []].sort((o, c) => {
+        const r = o.order ?? 0, n = c.order ?? 0;
+        return r - n || D(o, c);
+      });
+    }
+  };
+}, Fe = (e) => e ? Array.isArray(e) ? [...e] : [e] : [], $e = (e) => {
+  const t = C({
+    name: "workbench.modes",
+    initialState: {
+      modes: {},
+      activeModeId: void 0
+    }
+  });
+  let a = [], o = /* @__PURE__ */ new Set(), c = /* @__PURE__ */ new Set(), r, n;
+  const l = (s) => Object.values(s.areas).flatMap((i) => i.widgets.map((u) => u.widgetId)), y = (s) => {
+    for (const i of l(s))
+      c.has(i) || o.add(i);
+  }, m = (s = {}) => {
+    const i = e.resolveContext();
+    r?.(), r = void 0;
+    for (let u = a.length - 1; u >= 0; u -= 1)
+      a[u]?.dispose();
+    for (const u of o)
+      i.layout.removeWidgetPlacement(u);
+    a = [], o = /* @__PURE__ */ new Set(), c = /* @__PURE__ */ new Set(), n?.dispose(), n = void 0, s.publish !== !1 && t.setState({
+      ...t.getState(),
+      activeModeId: void 0
+    }, !1, "deactivateMode");
+  }, g = (s) => {
+    const i = e.resolveContext(), u = t.getState().modes[s];
+    if (!u) throw new Error(`Workbench mode not registered: ${s}`);
+    c = new Set(l(i.layout.getLayout()));
+    const p = i.context.createScope("workbench.mode");
+    p.set("activeWorkbenchMode", s), p.set(`workbenchMode.${s}`, !0), n = p, r = i.layout.store.subscribe((b) => y(b.layout)), t.setState({
+      ...t.getState(),
+      activeModeId: s
+    }, !1, "activateMode");
+    try {
+      a = Fe(u.activate(i)), y(i.layout.getLayout());
+    } catch (b) {
+      throw m(), b;
+    }
+  };
+  return {
+    store: t,
+    registerMode(s) {
+      const i = t.getState();
+      if (i.modes[s.id]) throw new Error(`Workbench mode already registered: ${s.id}`);
+      return t.setState({
+        ...i,
+        modes: {
+          ...i.modes,
+          [s.id]: s
+        }
+      }, !1, "registerMode"), w(() => {
+        const u = t.getState();
+        if (u.modes[s.id] !== s) return;
+        u.activeModeId === s.id && m();
+        const {
+          [s.id]: h,
+          ...p
+        } = u.modes;
+        t.setState({
+          ...t.getState(),
+          modes: p
+        }, !1, "unregisterMode");
+      });
+    },
+    getMode(s) {
+      return t.getState().modes[s];
+    },
+    listModes() {
+      return Object.values(t.getState().modes);
+    },
+    getActiveModeId() {
+      return t.getState().activeModeId;
+    },
+    setActiveMode(s) {
+      s !== t.getState().activeModeId && (m({
+        publish: s === void 0
+      }), s !== void 0 && g(s));
+    },
+    onDidChangeActive(s) {
+      const i = t.subscribeSelector((u) => u.activeModeId, () => s());
+      return w(i);
+    }
+  };
+}, Q = (e, t) => t.priority - e.priority || e.id.localeCompare(t.id), Ne = () => {
+  throw new Error("navigation.openTarget: no dispatcher available (configure resolveDispatcher)");
+}, je = async (e, t) => e.kind === "resource" ? t.openResource(e.resource, e.input) : e.kind === "view" ? t.openWidget(e.widgetId, e.input) : t.executeCommand(e.commandId, e.args), _e = (e, t) => {
+  if (e.kind === "resource" && t.canOpenResource?.(e.resource) === !1)
+    throw new Error(`Cannot open navigation resource target: ${e.resource.uri}`);
+  if (e.kind === "view" && t.canOpenWidget?.(e.widgetId) === !1)
+    throw new Error(`Cannot open navigation view target: ${e.widgetId}`);
+  if (e.kind === "command" && t.canExecuteCommand?.(e.commandId) === !1)
+    throw new Error(`Cannot open navigation command target: ${e.commandId}`);
+}, qe = (e) => e.kind === "compound" ? e.targets : [e], Ke = (e = {}) => {
+  const t = e.resolveDispatcher ?? Ne, a = C({
+    name: "workbench.navigation",
+    initialState: {
+      parsers: {},
+      navigators: {}
+    }
+  }), o = (r, n) => {
+    const {
+      [n]: l,
+      ...y
+    } = r;
+    return y;
+  }, c = {
+    store: a,
+    registerParser(r, n) {
+      const l = a.getState();
+      if (l.parsers[r.id]) throw new Error(`Navigation parser already registered: ${r.id}`);
+      const {
+        priority: y,
+        ...m
+      } = r, g = {
+        ...m,
+        ...x({
+          ...n,
+          priority: n?.priority ?? y
+        })
+      };
+      return a.setState({
+        ...l,
+        parsers: {
+          ...l.parsers,
+          [r.id]: g
+        }
+      }, !1, "registerParser"), w(() => {
+        const s = a.getState();
+        s.parsers[r.id] === g && a.setState({
+          ...s,
+          parsers: o(s.parsers, r.id)
+        }, !1, "unregisterParser");
+      });
+    },
+    listParsers() {
+      return Object.values(a.getState().parsers).sort(Q);
+    },
+    resolveLocation(r) {
+      const n = this.listParsers().find((l) => l.canParse(r));
+      if (!n) throw new Error(`No navigation parser registered for location: ${r}`);
+      return n.parse(r);
+    },
+    async openTarget(r) {
+      const n = t(), l = qe(r), y = [];
+      for (const g of l) _e(g, n);
+      const m = r.kind === "compound" ? n.createCheckpoint?.() : void 0;
+      try {
+        for (const g of l) {
+          const s = await je(g, n);
+          y.push(s);
+        }
+      } catch (g) {
+        throw m?.(), g;
+      }
+      return y;
+    },
+    async navigate(r) {
+      return c.openTarget(c.resolveLocation(r));
+    },
+    registerNavigator(r, n) {
+      const l = a.getState();
+      if (l.navigators[r.id]) throw new Error(`Resource navigator already registered: ${r.id}`);
+      const {
+        priority: y,
+        ...m
+      } = r, g = {
+        ...m,
+        ...x({
+          ...n,
+          priority: n?.priority ?? y
+        })
+      };
+      return a.setState({
+        ...l,
+        navigators: {
+          ...l.navigators,
+          [r.id]: g
+        }
+      }, !1, "registerNavigator"), w(() => {
+        const s = a.getState();
+        s.navigators[r.id] === g && a.setState({
+          ...s,
+          navigators: o(s.navigators, r.id)
+        }, !1, "unregisterNavigator");
+      });
+    },
+    listNavigators() {
+      return Object.values(a.getState().navigators).sort(Q);
+    },
+    createHref(r) {
+      const n = this.listNavigators().find((l) => l.createHref && l.canNavigate(r));
+      if (!n?.createHref) throw new Error(`No navigator href registered for resource kind: ${r.kind}`);
+      return n.createHref(r);
+    },
+    async navigateResource(r) {
+      const n = this.listNavigators().find((l) => l.canNavigate(r));
+      if (!n) throw new Error(`No navigator registered for resource kind: ${r.kind}`);
+      return await n.navigate(r);
+    }
+  };
+  return c;
+}, Ve = () => {
+  const e = C({
+    name: "workbench.notifications",
+    initialState: {
+      notifications: {}
+    }
+  }), t = /* @__PURE__ */ new Set();
+  let a = 0;
+  const o = (c) => {
+    for (const r of t) r(c);
+  };
+  return {
+    store: e,
+    show(c, r) {
+      let n = c.id;
+      n || (a += 1, n = `workbench.notification.${a.toString()}`);
+      const l = {
+        ...x(r),
+        ...c,
+        id: n,
+        createdAt: c.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+      }, y = e.getState();
+      return e.setState({
+        notifications: {
+          ...y.notifications,
+          [n]: l
+        }
+      }, !1, "showNotification"), o({
+        type: "show",
+        id: n,
+        notification: l
+      }), l;
+    },
+    dismiss(c) {
+      const r = e.getState();
+      if (!r.notifications[c]) return !1;
+      const {
+        [c]: n,
+        ...l
+      } = r.notifications;
+      return e.setState({
+        notifications: l
+      }, !1, "dismissNotification"), o({
+        type: "dismiss",
+        id: c
+      }), !0;
+    },
+    clear() {
+      const c = Object.keys(e.getState().notifications);
+      e.setState({
+        notifications: {}
+      }, !1, "clearNotifications");
+      for (const r of c) o({
+        type: "dismiss",
+        id: r
+      });
+    },
+    listNotifications() {
+      return Object.values(e.getState().notifications).sort((c, r) => r.createdAt.localeCompare(c.createdAt));
+    },
+    subscribe(c) {
+      return t.add(c), w(() => {
+        t.delete(c);
+      });
+    }
+  };
+}, U = (e, t) => `${e}:${t.scope}:${t.scopeId ?? ""}`, ze = () => {
+  const e = /* @__PURE__ */ new Map();
+  return {
+    getValue(t, a) {
+      return e.get(U(t, a));
+    },
+    setValue(t, a, o) {
+      e.set(U(t, o), a);
+    }
+  };
+}, He = (e = {}) => {
+  const t = C({
+    name: "workbench.preferences",
+    initialState: {
+      schemas: {}
+    }
+  }), a = e.persistence ?? ze();
+  return {
+    store: t,
+    registerSchema(o, c) {
+      const r = Object.keys(o.properties), n = t.getState();
+      for (const y of r)
+        if (n.schemas[y]) throw new Error(`Preference schema already registered: ${y}`);
+      const l = {};
+      for (const y of r) {
+        const m = o.properties[y];
+        m && (l[y] = {
+          ...m,
+          ownerId: c?.ownerId ?? "workbench.core",
+          source: c?.source ?? "module"
+        });
+      }
+      return t.setState({
+        schemas: {
+          ...n.schemas,
+          ...l
+        }
+      }, !1, "registerSchema"), w(() => {
+        const m = {
+          ...t.getState().schemas
+        };
+        for (const g of r) delete m[g];
+        t.setState({
+          schemas: m
+        }, !1, "unregisterSchema");
+      });
+    },
+    getSchema(o) {
+      return t.getState().schemas[o];
+    },
+    setValue(o, c, r) {
+      if (!t.getState().schemas[o]) throw new Error(`Preference schema not registered: ${o}`);
+      a.setValue(o, c, r);
+    },
+    getValue(o, c) {
+      if (c) {
+        const n = a.getValue(o, c);
+        if (n !== void 0) return n;
+      }
+      const r = a.getValue(o, {
+        scope: "user"
+      });
+      return r !== void 0 ? r : t.getState().schemas[o]?.default;
+    }
+  };
+}, Qe = (e) => {
+  const {
+    rendererRegistry: t
+  } = e, a = C({
+    name: "workbench.controlsRenderers",
+    initialState: {
+      renderers: {}
+    }
+  }), o = /* @__PURE__ */ new Set();
+  let c = () => null;
+  const r = (n) => {
+    const l = a.getState().renderers[n];
+    if (!l) throw new Error(`Controls renderer not registered: ${n}`);
+    return l;
+  };
+  return {
+    controlsStore: a,
+    setControlsRendererImplementation(n) {
+      c = n;
+    },
+    registerControlsRenderer(n, l) {
+      const y = a.getState();
+      if (y.renderers[n.id])
+        throw new Error(`Controls renderer already registered: ${n.id}`);
+      const m = {
+        ...x(l),
+        ...n
+      };
+      a.setState({
+        ...y,
+        renderers: {
+          ...y.renderers,
+          [n.id]: m
+        }
+      }, !1, "registerControlsRenderer");
+      const g = t.registerRenderer({
+        id: n.id,
+        render: (s) => c({
+          ...s,
+          controlsRendererId: n.id
+        })
+      });
+      return w(() => {
+        g.dispose();
+        const s = a.getState();
+        if (s.renderers[n.id] !== m) return;
+        const {
+          [n.id]: i,
+          ...u
+        } = s.renderers;
+        a.setState({
+          renderers: u
+        }, !1, "unregisterControlsRenderer");
+      });
+    },
+    getControlsRenderer(n) {
+      return a.getState().renderers[n];
+    },
+    listControlsRenderers() {
+      return Object.values(a.getState().renderers).sort(D);
+    },
+    refreshControlsRenderer(n) {
+      r(n);
+      const l = {
+        controlsRendererId: n
+      };
+      for (const y of o) y(l);
+    },
+    onDidRefreshControlsRenderer(n) {
+      return o.add(n), w(() => {
+        o.delete(n);
+      });
+    }
+  };
+}, Ue = (e) => {
+  const {
+    rendererRegistry: t
+  } = e, a = C({
+    name: "workbench.dataRenderers",
+    initialState: {
+      renderers: {}
+    }
+  }), o = /* @__PURE__ */ new Set();
+  let c = () => null;
+  const r = (n) => {
+    const l = a.getState().renderers[n];
+    if (!l) throw new Error(`Data renderer not registered: ${n}`);
+    return l;
+  };
+  return {
+    dataStore: a,
+    setDataRendererImplementation(n) {
+      c = n;
+    },
+    registerDataRenderer(n, l) {
+      const y = a.getState();
+      if (y.renderers[n.id]) throw new Error(`Data renderer already registered: ${n.id}`);
+      const m = {
+        ...x(l),
+        ...n
+      };
+      a.setState({
+        ...y,
+        renderers: {
+          ...y.renderers,
+          [n.id]: m
+        }
+      }, !1, "registerDataRenderer");
+      const g = t.registerRenderer({
+        id: n.id,
+        render: (s) => c({
+          ...s,
+          dataRendererId: n.id
+        })
+      });
+      return w(() => {
+        g.dispose();
+        const s = a.getState();
+        if (s.renderers[n.id] !== m) return;
+        const {
+          [n.id]: i,
+          ...u
+        } = s.renderers;
+        a.setState({
+          renderers: u
+        }, !1, "unregisterDataRenderer");
+      });
+    },
+    getDataRenderer(n) {
+      return a.getState().renderers[n];
+    },
+    listDataRenderers() {
+      return Object.values(a.getState().renderers).sort(D);
+    },
+    refreshDataRenderer(n) {
+      r(n);
+      const l = {
+        dataRendererId: n
+      };
+      for (const y of o) y(l);
+    },
+    onDidRefreshDataRenderer(n) {
+      return o.add(n), w(() => {
+        o.delete(n);
+      });
+    }
+  };
+}, Xe = (e) => {
+  const {
+    rendererRegistry: t
+  } = e, a = C({
+    name: "workbench.fileRenderers",
+    initialState: {
+      renderers: {}
+    }
+  }), o = /* @__PURE__ */ new Set();
+  let c = () => null;
+  const r = (n) => {
+    const l = a.getState().renderers[n];
+    if (!l) throw new Error(`File renderer not registered: ${n}`);
+    return l;
+  };
+  return {
+    fileRendererStore: a,
+    setFileRendererImplementation(n) {
+      c = n;
+    },
+    registerFileRenderer(n, l) {
+      const y = a.getState();
+      if (y.renderers[n.id]) throw new Error(`File renderer already registered: ${n.id}`);
+      const m = {
+        ...x(l),
+        ...n
+      };
+      a.setState({
+        ...y,
+        renderers: {
+          ...y.renderers,
+          [n.id]: m
+        }
+      }, !1, "registerFileRenderer");
+      const g = t.registerRenderer({
+        id: n.id,
+        render: (s) => c({
+          ...s,
+          fileRendererId: n.id
+        })
+      });
+      return w(() => {
+        g.dispose();
+        const s = a.getState();
+        if (s.renderers[n.id] !== m) return;
+        const {
+          [n.id]: i,
+          ...u
+        } = s.renderers;
+        a.setState({
+          renderers: u
+        }, !1, "unregisterFileRenderer");
+      });
+    },
+    getFileRenderer(n) {
+      return a.getState().renderers[n];
+    },
+    listFileRenderers() {
+      return Object.values(a.getState().renderers).sort(D);
+    },
+    refreshFileRenderer(n) {
+      r(n);
+      const l = {
+        fileRendererId: n
+      };
+      for (const y of o) y(l);
+    },
+    onDidRefreshFileRenderer(n) {
+      return o.add(n), w(() => {
+        o.delete(n);
+      });
+    }
+  };
+}, X = (e) => ({
+  expandedNodeIds: [...e.defaultExpandedNodeIds ?? []],
+  expandedSectionIds: [...e.defaultExpandedSectionIds ?? []]
+}), Ye = (e, t) => {
+  const a = (t.defaultExpandedSectionIds ?? []).filter((o) => !e.expandedSectionIds.includes(o));
+  return a.length === 0 ? e : {
+    ...e,
+    expandedSectionIds: [...e.expandedSectionIds, ...a]
+  };
+}, Y = (e, t, a) => a ? e.includes(t) ? e : [...e, t] : e.includes(t) ? e.filter((o) => o !== t) : e, Ge = (e) => {
+  const {
+    rendererRegistry: t,
+    persistence: a
+  } = e, o = a?.getTreeStates(), c = C({
+    name: "workbench.treeRenderers",
+    initialState: {
+      trees: {},
+      statesByTreeId: o?.statesByTreeId ?? {},
+      refreshKeysByTreeId: {}
+    }
+  }), r = /* @__PURE__ */ new Set();
+  let n = () => null;
+  const l = (s) => {
+    const i = c.getState().trees[s];
+    if (!i) throw new Error(`Tree renderer not registered: ${s}`);
+    return i;
+  }, y = (s) => {
+    const i = c.getState(), u = i.statesByTreeId[s];
+    if (u) return u;
+    const h = i.trees[s];
+    if (!h) throw new Error(`Tree renderer not registered: ${s}`);
+    const p = X(h);
+    return c.setState({
+      ...i,
+      statesByTreeId: {
+        ...i.statesByTreeId,
+        [s]: p
+      }
+    }, !1, "ensureTreeState"), p;
+  }, m = () => {
+    if (!a) return;
+    const s = {};
+    for (const [i, u] of Object.entries(c.getState().statesByTreeId)) {
+      const {
+        loading: h,
+        ...p
+      } = u;
+      s[i] = p;
+    }
+    a.setTreeStates({
+      statesByTreeId: s
+    });
+  }, g = (s, i, u) => {
+    const h = y(s), p = i(h);
+    if (p === h) return;
+    const b = c.getState();
+    c.setState({
+      ...b,
+      statesByTreeId: {
+        ...b.statesByTreeId,
+        [s]: p
+      }
+    }, !1, u), m();
+  };
+  return {
+    treeStore: c,
+    setTreeRendererImplementation(s) {
+      n = s;
+    },
+    registerTreeRenderer(s, i) {
+      const u = c.getState();
+      if (u.trees[s.id]) throw new Error(`Tree renderer already registered: ${s.id}`);
+      const h = {
+        ...x(i),
+        ...s
+      }, p = u.statesByTreeId[s.id], b = p ? Ye(p, s) : X(s);
+      c.setState({
+        ...u,
+        trees: {
+          ...u.trees,
+          [s.id]: h
+        },
+        statesByTreeId: {
+          ...u.statesByTreeId,
+          [s.id]: b
+        }
+      }, !1, "registerTreeRenderer");
+      const I = t.registerRenderer({
+        id: s.id,
+        render: (P) => n({
+          ...P,
+          treeId: s.id
+        })
+      });
+      return w(() => {
+        I.dispose();
+        const P = c.getState();
+        if (P.trees[s.id] !== h) return;
+        const {
+          [s.id]: d,
+          ...f
+        } = P.trees, {
+          [s.id]: S,
+          ...v
+        } = P.statesByTreeId, {
+          [s.id]: R,
+          ...A
+        } = P.refreshKeysByTreeId;
+        c.setState({
+          trees: f,
+          statesByTreeId: v,
+          refreshKeysByTreeId: A
+        }, !1, "unregisterTreeRenderer"), m();
+      });
+    },
+    getTreeRenderer(s) {
+      return c.getState().trees[s];
+    },
+    listTreeRenderers() {
+      return Object.values(c.getState().trees).sort(D);
+    },
+    async getBody(s, i = {}) {
+      return await l(s).getBody(i);
+    },
+    async getHeader(s, i = {}) {
+      const u = l(s);
+      return u.getHeader ? await u.getHeader(i) : [];
+    },
+    async getFooter(s, i = {}) {
+      const u = l(s);
+      return u.getFooter ? await u.getFooter(i) : [];
+    },
+    async getChildren(s, i, u = {}) {
+      return await l(s).getChildren(i, u);
+    },
+    getTreeState(s) {
+      const i = y(s);
+      return {
+        expandedNodeIds: [...i.expandedNodeIds],
+        expandedSectionIds: [...i.expandedSectionIds],
+        selectedNodeId: i.selectedNodeId,
+        loading: i.loading
+      };
+    },
+    setNodeExpanded(s, i, u) {
+      l(s), g(s, (h) => {
+        const p = Y(h.expandedNodeIds, i, u);
+        return p === h.expandedNodeIds ? h : {
+          ...h,
+          expandedNodeIds: p
+        };
+      }, "setNodeExpanded");
+    },
+    setSectionExpanded(s, i, u) {
+      l(s), g(s, (h) => {
+        const p = Y(h.expandedSectionIds, i, u);
+        return p === h.expandedSectionIds ? h : {
+          ...h,
+          expandedSectionIds: p
+        };
+      }, "setSectionExpanded");
+    },
+    setSelectedNode(s, i) {
+      l(s), g(s, (u) => u.selectedNodeId === i ? u : {
+        ...u,
+        selectedNodeId: i
+      }, "setSelectedNode");
+    },
+    setLoading(s, i) {
+      l(s);
+      const u = y(s);
+      if (u.loading === i) return;
+      const h = c.getState();
+      c.setState({
+        ...h,
+        statesByTreeId: {
+          ...h.statesByTreeId,
+          [s]: {
+            ...u,
+            loading: i
+          }
+        }
+      }, !1, "setLoading");
+    },
+    refresh(s) {
+      l(s);
+      const i = c.getState(), u = i.refreshKeysByTreeId[s] ?? 0;
+      c.setState({
+        ...i,
+        refreshKeysByTreeId: {
+          ...i.refreshKeysByTreeId,
+          [s]: u + 1
+        }
+      }, !1, "refreshTreeRenderer");
+      const h = {
+        treeId: s
+      };
+      for (const p of r) p(h);
+    },
+    onDidRefresh(s) {
+      return r.add(s), w(() => {
+        r.delete(s);
+      });
+    }
+  };
+}, G = (e, t) => (e.order ?? 0) - (t.order ?? 0) || D(e, t), Je = () => {
+  const e = C({
+    name: "workbench.settings",
+    initialState: {
+      sections: {},
+      panels: {},
+      revision: 0
+    }
+  });
+  return {
+    store: e,
+    refresh() {
+      const t = e.getState();
+      e.setState({
+        ...t,
+        revision: t.revision + 1
+      }, !1, "refreshSettings");
+    },
+    registerSection(t, a) {
+      const o = e.getState();
+      if (o.sections[t.id]) throw new Error(`Settings section already registered: ${t.id}`);
+      const c = {
+        ...x(a),
+        ...t
+      };
+      return e.setState({
+        ...o,
+        sections: {
+          ...o.sections,
+          [t.id]: c
+        }
+      }, !1, "registerSection"), w(() => {
+        const r = e.getState();
+        if (r.sections[t.id] !== c) return;
+        const {
+          [t.id]: n,
+          ...l
+        } = r.sections;
+        e.setState({
+          ...r,
+          sections: l
+        }, !1, "unregisterSection");
+      });
+    },
+    registerPanel(t, a) {
+      const o = e.getState();
+      if (o.panels[t.id]) throw new Error(`Settings panel already registered: ${t.id}`);
+      const c = {
+        ...x(a),
+        ...t
+      };
+      return e.setState({
+        ...o,
+        panels: {
+          ...o.panels,
+          [t.id]: c
+        }
+      }, !1, "registerPanel"), w(() => {
+        const r = e.getState();
+        if (r.panels[t.id] !== c) return;
+        const {
+          [t.id]: n,
+          ...l
+        } = r.panels;
+        e.setState({
+          ...r,
+          panels: l
+        }, !1, "unregisterPanel");
+      });
+    },
+    getSection(t) {
+      return e.getState().sections[t];
+    },
+    getPanel(t) {
+      return e.getState().panels[t];
+    },
+    listSections() {
+      return Object.values(e.getState().sections).sort(G);
+    },
+    listPanels() {
+      return Object.values(e.getState().panels).sort(G);
+    }
+  };
+}, Ze = () => {
+  const e = C({
+    name: "workbench.fileIconThemes",
+    initialState: {
+      themes: []
+    }
+  }), t = /* @__PURE__ */ new Set(), a = () => {
+    e.setState({
+      themes: [...t].flat()
+    }, !1, "syncFileIconThemes");
+  };
+  return {
+    store: e,
+    register(o) {
+      return t.add(o), a(), w(() => {
+        t.delete(o) && a();
+      });
+    },
+    listThemes() {
+      return e.getState().themes;
+    }
+  };
+}, et = () => {
+  const e = C({
+    name: "workbench.themes",
+    initialState: {
+      themes: []
+    }
+  }), t = /* @__PURE__ */ new Set(), a = () => {
+    e.setState({
+      themes: [...t].flat()
+    }, !1, "syncThemes");
+  };
+  return {
+    store: e,
+    register(o) {
+      return t.add(o), a(), w(() => {
+        t.delete(o) && a();
+      });
+    },
+    listThemes() {
+      return e.getState().themes;
+    }
+  };
+}, tt = (e) => (t) => e.listProviders().some((o) => o.kind === t.kind) ? e.listResources("").some((o) => o.resource.uri === t.uri) : !0, rt = ({
+  layout: e,
+  isInScope: t
+}) => {
+  const a = e.store.subscribeSelector((o) => W(o.layout.areas[N("primary")])?.resourceUri, () => {
+    const o = e.getLayout(), c = $(o, "primary");
+    for (const r of ge({
+      layout: o,
+      primary: c,
+      isInScope: t
+    }))
+      r.action === "clear" && e.clearArea(r.area);
+  });
+  return w(a);
+}, st = "left", nt = (e, t, a) => {
+  e.panels.setOpen(t, a), e.layout.setAreaVisible(t, a);
+}, ot = (e, t) => {
+  nt(e, t, !e.panels.isOpen(t));
+}, at = [{
+  id: "workbench.toggleCommandPalette",
+  label: "Toggle Command Palette",
+  icon: "Command",
+  keybinding: "Mod+K",
+  execute: (e) => e.commandPalette.toggle()
+}, {
+  id: "workbench.action.showCommands",
+  label: "Run Command",
+  icon: "Terminal",
+  keybinding: "Alt+Shift+K",
+  execute: (e) => e.commandPalette.open({
+    initialQuery: "> "
+  })
+}, {
+  id: "workbench.action.changeTheme",
+  label: "Change Theme",
+  icon: "Palette",
+  keybinding: "Alt+Shift+T",
+  execute: (e) => e.commandPalette.open({
+    view: "theme"
+  })
+}, {
+  id: "workbench.action.navigateBack",
+  label: "Navigate Back",
+  icon: "ArrowLeft",
+  keybinding: "Alt+Shift+ArrowLeft",
+  execute: (e) => {
+    e.history.goBack();
+  }
+}, {
+  id: "workbench.action.navigateForward",
+  label: "Navigate Forward",
+  icon: "ArrowRight",
+  keybinding: "Alt+Shift+ArrowRight",
+  execute: (e) => {
+    e.history.goForward();
+  }
+}, {
+  id: "workbench.toggleSideBar",
+  label: "Toggle Sidebar",
+  icon: "PanelLeft",
+  keybinding: "Mod+B",
+  execute: (e) => ot(e, st)
+}], it = (e) => {
+  for (const t of at)
+    e.commands.registerCommand({
+      id: t.id,
+      label: t.label,
+      category: "Workbench",
+      icon: t.icon,
+      when: "!inputFocus"
+    }, {
+      execute: () => t.execute(e)
+    }), e.keybindings.registerKeybinding({
+      commandId: t.id,
+      keybinding: t.keybinding,
+      when: "!inputFocus"
+    }), e.layout.registerMenuItem(K, {
+      commandId: t.id,
+      group: "Workbench"
+    });
+  e.commands.registerCommand({
+    id: "workbench.action.switchMode",
+    label: "Switch Mode",
+    category: "Workbench",
+    icon: "PanelTop",
+    when: "!inputFocus"
+  }, {
+    execute: (t) => {
+      if (!t?.modeId) {
+        e.commandPalette.open({
+          view: "mode"
+        });
+        return;
+      }
+      if (!e.modes.getMode(t.modeId)) throw new Error(`Workbench mode not registered: ${t.modeId}`);
+      e.modes.setActiveMode(t.modeId);
+    }
+  }), e.layout.registerMenuItem(K, {
+    commandId: "workbench.action.switchMode",
+    group: "Workbench"
+  });
+}, k = (e, t) => ({
+  ...t,
+  source: e.source,
+  ownerId: e.ownerId
+}), ee = (e) => e ? Array.isArray(e) ? [...e] : [e] : [], te = (e) => {
+  for (let t = e.length - 1; t >= 0; t -= 1)
+    e[t]?.dispose();
+}, re = (e, t) => {
+  const a = e.context.createScope(t.ownerId);
+  t.track(a);
+  const o = (r) => (t.track(r), r);
+  return {
+    ...e,
+    onDidChangePrimaryResource: (r) => o(e.onDidChangePrimaryResource(r)),
+    onDidChangeActiveResource: (r) => o(e.onDidChangeActiveResource(r)),
+    breadcrumbs: {
+      ...e.breadcrumbs,
+      setItems: (r) => o(e.breadcrumbs.setItems(r)),
+      onDidChange: (r) => o(e.breadcrumbs.onDidChange(r))
+    },
+    commandPalette: {
+      ...e.commandPalette,
+      onDidChange: (r) => o(e.commandPalette.onDidChange(r))
+    },
+    context: {
+      ...e.context,
+      set: (r, n) => a.set(r, n),
+      delete: (r) => a.delete(r),
+      createScope: (r) => o(e.context.createScope(r))
+    },
+    focus: {
+      ...e.focus,
+      onDidChange: (r) => o(e.focus.onDidChange(r))
+    },
+    commands: {
+      ...e.commands,
+      registerCommand: (r, n, l) => o(e.commands.registerCommand(r, n, k(t, l))),
+      onDidExecuteError: (r) => o(e.commands.onDidExecuteError(r))
+    },
+    keybindings: {
+      ...e.keybindings,
+      registerKeybinding: (r, n) => o(e.keybindings.registerKeybinding(r, k(t, n)))
+    },
+    lastResource: {
+      ...e.lastResource
+    },
+    layout: {
+      ...e.layout,
+      openWidget: (r, n) => {
+        const l = e.layout.openWidget(r, {
+          ...n,
+          ownerId: t.ownerId,
+          source: t.source
+        });
+        return o(w(() => e.layout.removeWidgetPlacement(l.widgetId))), l;
+      },
+      registerPlaceholder: (r, n) => o(e.layout.registerPlaceholder(r, k(t, n))),
+      registerWidget: (r, n) => o(e.layout.registerWidget(r, k(t, n))),
+      registerMenuItem: (r, n, l) => o(e.layout.registerMenuItem(r, n, k(t, l))),
+      onDidChangePersistenceScope: (r) => o(e.layout.onDidChangePersistenceScope(r))
+    },
+    modes: {
+      ...e.modes,
+      registerMode: (r) => o(e.modes.registerMode({
+        ...r,
+        activate: () => {
+          const n = [], l = re(e, {
+            ...t,
+            track: (m) => {
+              n.push(m);
+            }
+          }), y = ee(r.activate(l));
+          return w(() => te([...n, ...y]));
+        }
+      })),
+      onDidChangeActive: (r) => o(e.modes.onDidChangeActive(r))
+    },
+    navigation: {
+      ...e.navigation,
+      registerNavigator: (r, n) => o(e.navigation.registerNavigator(r, k(t, n))),
+      registerParser: (r, n) => o(e.navigation.registerParser(r, k(t, n)))
+    },
+    notifications: {
+      ...e.notifications,
+      show: (r, n) => e.notifications.show(r, k(t, n))
+    },
+    panels: {
+      ...e.panels,
+      onDidChange: (r) => o(e.panels.onDidChange(r))
+    },
+    preferences: {
+      ...e.preferences,
+      registerSchema: (r, n) => o(e.preferences.registerSchema(r, k(t, n)))
+    },
+    renderers: {
+      ...e.renderers,
+      registerRenderer: (r) => o(e.renderers.registerRenderer(r)),
+      registerTreeRenderer: (r, n) => o(e.renderers.registerTreeRenderer(r, k(t, n))),
+      registerDataRenderer: (r, n) => o(e.renderers.registerDataRenderer(r, k(t, n))),
+      registerFileRenderer: (r, n) => o(e.renderers.registerFileRenderer(r, k(t, n))),
+      registerControlsRenderer: (r, n) => o(e.renderers.registerControlsRenderer(r, k(t, n))),
+      onDidChange: (r) => o(e.renderers.onDidChange(r)),
+      onDidRefresh: (r) => o(e.renderers.onDidRefresh(r))
+    },
+    resources: {
+      ...e.resources,
+      registerKind: (r, n) => o(e.resources.registerKind(r, k(t, n))),
+      registerOpener: (r) => o(e.resources.registerOpener(r)),
+      registerProvider: (r) => o(e.resources.registerProvider(r)),
+      onDidOpenResource: (r) => o(e.resources.onDidOpenResource(r))
+    },
+    settings: {
+      ...e.settings,
+      registerSection: (r, n) => o(e.settings.registerSection(r, k(t, n))),
+      registerPanel: (r, n) => o(e.settings.registerPanel(r, k(t, n)))
+    },
+    sessionPanel: {
+      ...e.sessionPanel,
+      onDidChange: (r) => o(e.sessionPanel.onDidChange(r))
+    },
+    themes: {
+      ...e.themes,
+      register: (r) => o(e.themes.register(r))
+    },
+    fileIconThemes: {
+      ...e.fileIconThemes,
+      register: (r) => o(e.fileIconThemes.register(r))
+    }
+  };
+}, ut = (e = {}) => {
+  const t = oe(), a = De({
+    context: t
+  }), o = /* @__PURE__ */ new Map(), c = ae(e.renderers), r = Ge({
+    rendererRegistry: c,
+    persistence: e.treePersistence
+  }), n = Ue({
+    rendererRegistry: c
+  }), l = Xe({
+    rendererRegistry: c
+  }), y = Qe({
+    rendererRegistry: c
+  }), m = {
+    breadcrumbs: me(),
+    commandPalette: fe(),
+    commands: a,
+    context: t,
+    focus: Se({
+      context: t
+    }),
+    history: void 0,
+    keybindings: ce({
+      commands: a,
+      context: t
+    }),
+    lastResource: Ie({
+      persistence: e.lastResourcePersistence,
+      openResource: (g) => m.resources.openResource(g, {
+        replaceActive: !0
+      })
+    }),
+    layout: {
+      ...Le({
+        persistence: e.layoutPersistence
+      }),
+      ...Oe({
+        commands: a
+      })
+    },
+    modes: void 0,
+    notifications: Ve(),
+    navigation: Ke({
+      resolveDispatcher: () => ({
+        createCheckpoint: () => {
+          const g = m.layout.getLayout();
+          return () => m.layout.restoreLayout(g);
+        },
+        canOpenResource: (g) => {
+          const s = m.resources.store.getState();
+          return !!(s.kinds[g.kind] && Object.values(s.openers).some((i) => i.canOpen(g)));
+        },
+        canOpenWidget: (g) => !!m.layout.getWidget(g),
+        canExecuteCommand: (g) => !!m.commands.getCommand(g),
+        openResource: (g, s) => m.resources.openResource(g, s),
+        openWidget: (g, s) => {
+          const i = m.layout.openWidget(g, s), u = m.layout.getWidget(g), h = s?.area ?? u?.area;
+          return h && (m.layout.setAreaVisible(h, !0), m.panels.isOpen(h) || m.panels.setOpen(h, !0)), i;
+        },
+        executeCommand: (g, s) => m.commands.executeCommand(g, s)
+      })
+    }),
+    panels: Re({
+      persistence: e.panelsPersistence
+    }),
+    preferences: He({
+      persistence: e.preferencePersistence
+    }),
+    renderers: {
+      ...c,
+      ...r,
+      ...n,
+      ...l,
+      ...y
+    },
+    commandPaletteResources: xe(),
+    resources: ie({
+      getPrimary: () => $(m.layout.getLayout(), "primary")
+    }),
+    settings: Je(),
+    sessionPanel: Pe({
+      initialMode: e.initialSessionPanelMode
+    }),
+    terminal: Ae(),
+    themes: et(),
+    fileIconThemes: Ze(),
+    getActiveResource() {
+      const g = m.layout.getLayout().activeWidgetId;
+      if (g)
+        for (const s of Object.values(m.layout.getLayout().areas)) {
+          const i = s.widgets.find((u) => u.widgetId === g);
+          if (i) return i.resource;
+        }
+    },
+    onDidChangeActiveResource(g) {
+      return w(m.layout.store.subscribeSelector((s) => s.layout.activeResourceUri, () => g(m.getActiveResource())));
+    },
+    getPrimaryResource() {
+      return $(m.layout.getLayout(), "primary");
+    },
+    onDidChangePrimaryResource(g) {
+      return w(m.layout.store.subscribeSelector((s) => W(s.layout.areas[N("primary")])?.resourceUri, () => g(m.getPrimaryResource())));
+    },
+    registerModule(g) {
+      if (o.has(g.id)) throw new Error(`Workbench module already registered: ${g.id}`);
+      const s = [], i = {
+        disposable: void 0
+      };
+      i.disposable = w(() => {
+        o.get(g.id) === i && (o.delete(g.id), te(s));
+      }), o.set(g.id, i);
+      try {
+        const u = re(m, {
+          ownerId: g.ownerId ?? g.id,
+          source: g.source ?? "module",
+          track: (h) => {
+            s.push(h);
+          }
+        });
+        s.push(...ee(g.activate(u)));
+      } catch (u) {
+        throw i.disposable.dispose(), u;
+      }
+      return i.disposable;
+    },
+    unregisterModule(g) {
+      o.get(g)?.disposable.dispose();
+    }
+  };
+  return m.modes = $e({
+    resolveContext: () => m
+  }), m.history = we({
+    layout: m.layout,
+    modes: m.modes,
+    resources: m.resources
+  }), m.layout.onDidChangePersistenceScope(() => {
+    const g = m.layout.getLayout();
+    for (const s of Object.values(g.areas))
+      m.panels.setOpen(s.id, s.visible);
+  }), m.onDidChangePrimaryResource((g) => {
+    g && m.lastResource.set(g);
+  }), rt({
+    layout: m.layout,
+    isInScope: e.isInScope ?? tt(m.resources)
+  }), it(m), m;
+};
+export {
+  De as a,
+  Qe as b,
+  xe as c,
+  Ue as d,
+  Ze as e,
+  Xe as f,
+  we as g,
+  Le as h,
+  Oe as i,
+  Ke as j,
+  Ve as k,
+  He as l,
+  Je as m,
+  et as n,
+  Ge as o,
+  me as p,
+  fe as q,
+  ut as r,
+  Se as s,
+  Ie as t,
+  $e as u,
+  Re as v,
+  Pe as w,
+  Ae as x,
+  he as y
+};
+//# sourceMappingURL=workbench-core-DFpwi8Lo.js.map