@pstdio/workbench 0.2.0 → 0.3.0

package/dist/index.js

@@ -1,64 +1,2978 @@
-import { c as a, a as t, b as s, d as o, e as c, f as n, g as i, h, i as l, j as R, k as g, l as b, m as d, n as u, o as y, p as k, q as C, r as m, s as P, t as W, u as w, v as M, w as x, x as f, y as p } from "./workbench-core-DFpwi8Lo.js";
-import { c as S, a as T, b as K, d as L, e as j, f as v, g as F, h as H, i as I, m as D, s as N, w as U, j as q, k as B, l as E } from "./context-key-service-C--cHa0B.js";
-import { c as z, g as G, a as J, l as O, b as Q, d as X, r as Y, e as Z, s as _, w as $ } from "./surface-reconcile-DkRf01ro.js";
-import { h as re, a as ae, r as te, w as se, b as oe, c as ce, d as ne } from "./workbench-menu-paths-CQVH6z4_.js";
+import { c as L, a as P, g as B, m as Ie, f as $, b as O, n as D, d as j, r as ye, e as A, h as Ce, i as U, j as be, k as ee, l as We, o as ke, p as Q, t as F, q as te, s as re, u as ne, v as Le, w as Ee, x as Te, y as xe, z as Me, A as De, B as Be, C as Oe } from "./context-key-service-W4QEfVdN.js";
+import { D as vr, E as pr, F as Rr, G as wr, H as Pr, I as Ir, J as Cr, K as Wr, L as kr, M as Lr, N as Er, O as Tr } from "./context-key-service-W4QEfVdN.js";
+import { w as K, m as Se, c as Ae, a as se } from "./layout-types-DMoZz38-.js";
+import { r as $e } from "./surface-map-C1pOTUmF.js";
+import { w as oe } from "./workbench-menu-paths-B_QJzcNU.js";
+import { h as Mr, a as Dr, r as Br, b as Or, c as Ar, d as $r, e as Fr } from "./workbench-menu-paths-B_QJzcNU.js";
+const hr = (e, t) => {
+  const s = e.walkHierarchy(t);
+  return s.map((n, i) => ({
+    title: n.label ?? n.id ?? e.getKind(n.kind)?.label ?? n.kind,
+    icon: n.icon ?? e.getKind(n.kind)?.icon,
+    resource: n,
+    ...i < s.length - 1 ? {
+      onClick: () => {
+        e.openResource(n, {
+          replaceActive: !0
+        });
+      }
+    } : {}
+  }));
+}, Fe = () => {
+  const e = L({
+    name: "workbench.breadcrumbs",
+    initialState: {
+      items: void 0
+    }
+  });
+  return {
+    store: e,
+    setItems(t) {
+      return e.setState({
+        items: t
+      }, !1, "setBreadcrumbItems"), P(() => {
+        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 s = e.subscribeSelector((n) => n.items, () => t());
+      return P(s);
+    }
+  };
+}, Ne = (e = {}) => {
+  const t = L({
+    name: "workbench.commandPalette",
+    initialState: {
+      open: e.initialOpen ?? !1,
+      view: "main",
+      initialQuery: "",
+      paramsRequest: null
+    }
+  }), s = (n) => {
+    const i = t.getState();
+    i.open === n.open && i.view === n.view && i.initialQuery === n.initialQuery || t.setState({
+      ...i,
+      ...n
+    }, !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(n = {}) {
+      s({
+        open: !0,
+        view: n.view ?? "main",
+        initialQuery: n.initialQuery ?? ""
+      });
+    },
+    close() {
+      s({
+        open: !1,
+        view: "main",
+        initialQuery: ""
+      });
+    },
+    toggle() {
+      s({
+        open: !t.getState().open,
+        view: "main",
+        initialQuery: ""
+      });
+    },
+    requestParams(n) {
+      t.setState({
+        ...t.getState(),
+        paramsRequest: n
+      }, !1, "requestCommandParams");
+    },
+    clearParams() {
+      t.getState().paramsRequest && t.setState({
+        ...t.getState(),
+        paramsRequest: null
+      }, !1, "clearCommandParams");
+    },
+    onDidChange(n) {
+      const i = t.subscribeSelector((r) => r.open, (r) => n(r));
+      return P(i);
+    }
+  };
+}, Ke = ["activity", "sidenav", "main", "secondary", "side", "status"], Ue = {
+  activity: "activityFocus",
+  sidenav: "sidenavFocus",
+  main: "mainFocus",
+  secondary: "secondaryFocus",
+  side: "sideFocus",
+  status: "statusFocus"
+}, je = (e) => {
+  const t = L({
+    name: "workbench.focus",
+    initialState: {
+      activeRegion: void 0
+    }
+  }), s = e.context.createScope("workbench.focus"), n = (i) => {
+    s.set("workbenchFocus", i !== void 0), s.set("activeWorkbenchFocusRegion", i);
+    for (const r of Ke)
+      s.set(Ue[r], r === i);
+  };
+  return n(void 0), {
+    store: t,
+    setActiveRegion(i) {
+      e.isRegionFocusable?.(i) !== !1 && t.getState().activeRegion !== i && (t.setState({
+        activeRegion: i
+      }, !1, "setActiveWorkbenchFocusRegion"), n(i));
+    },
+    clearFocus() {
+      t.getState().activeRegion !== void 0 && (t.setState({
+        activeRegion: void 0
+      }, !1, "clearWorkbenchFocusRegion"), n(void 0));
+    },
+    getActiveRegion() {
+      return t.getState().activeRegion;
+    },
+    onDidChange(i) {
+      const r = t.subscribeSelector((o) => o.activeRegion, (o) => i(o));
+      return P(r);
+    }
+  };
+}, X = ["main", "secondary"], Y = (e, t) => t.role ?? e.getWidget(t.contributionId)?.role ?? "content", _e = (e, t) => {
+  if (t.instanceKey) {
+    const s = $(e.getLayout(), t.instanceKey)?.placement;
+    if (s) return s;
+  }
+  for (const s of K) {
+    const n = e.getLayout().regions[s].widgets.find((i) => i.contributionId === t.contributionId && i.resourceUri === t.resourceUri);
+    if (n) return n;
+  }
+}, He = (e) => ({
+  contributionId: e.contributionId,
+  resourceUri: e.resourceUri,
+  instanceKey: e.widgetId
+}), qe = (e, t) => e?.contributionId === t?.contributionId && e?.resourceUri === t?.resourceUri && e?.instanceKey === t?.instanceKey, Ve = (e, t) => {
+  const s = {}, n = B(e.getLayout());
+  for (const i of X) {
+    const r = e.getLayout().regions[i], o = r.widgets.find((u) => u.widgetId === r.activeWidgetId), c = o ? e.getWidget(o.contributionId) : void 0;
+    o && c && Y(e, o) === "sub-panel" && Ie(c, n?.resource, t, o) && (s[i] = He(o));
+  }
+  return s;
+}, ze = (e) => B(e.getLayout()), Qe = (e, t) => ({
+  key: e.resourceUri ? `${t ?? "global"}:resource:${e.resourceUri}` : `${t ?? "global"}:widget:${e.contributionId}:${e.widgetId}`,
+  modeId: t,
+  resource: e.resource,
+  contributionId: e.contributionId,
+  instanceKey: e.widgetId,
+  title: e.title
+}), Ye = (e) => {
+  const t = e.modes?.getActiveModeId(), s = ze(e.layout), n = Date.now(), i = {
+    entryId: `history-${n}-${e.counter}`,
+    recordedAt: n,
+    selectedSubPanels: Ve(e.layout, t)
+  };
+  if (s)
+    return {
+      ...i,
+      location: Qe(s, t),
+      kind: s.resource ? "resource" : "widget",
+      modeId: t,
+      resource: s.resource,
+      widgetId: s.widgetId,
+      contributionId: s.contributionId,
+      title: s.title
+    };
+  if (t)
+    return {
+      ...i,
+      location: {
+        key: `mode:${t}`,
+        modeId: t,
+        title: e.modes?.getMode(t)?.label ?? t
+      },
+      kind: "mode",
+      modeId: t,
+      title: e.modes?.getMode(t)?.label ?? t
+    };
+}, q = (e, t) => !e || !t || e.location.key !== t.location.key ? !1 : X.every((s) => qe(e.selectedSubPanels[s], t.selectedSubPanels[s])), _ = (e) => {
+  const t = [];
+  for (const s of e) {
+    const n = t.length - 1;
+    q(t[n], s) ? t[n] = s : t.push(s);
+  }
+  return t;
+}, Ge = (e, t) => {
+  const s = {
+    ...e.selectedSubPanels
+  };
+  for (const n of K) {
+    const i = s[n];
+    (i?.instanceKey === t.widgetId || i?.contributionId === t.contributionId && i.resourceUri === t.resourceUri) && delete s[n];
+  }
+  return {
+    ...e,
+    selectedSubPanels: s
+  };
+}, Je = (e) => {
+  const {
+    closedSubPanel: t,
+    counter: s,
+    current: n,
+    modeId: i,
+    placement: r
+  } = e, o = Date.now();
+  return n ? {
+    ...n,
+    entryId: `history-${o}-${s}`,
+    recordedAt: o,
+    closedSubPanel: t
+  } : {
+    entryId: `history-${o}-${s}`,
+    recordedAt: o,
+    location: {
+      key: r.resourceUri ? `${i ?? "global"}:resource:${r.resourceUri}` : `${i ?? "global"}:widget:${r.contributionId}:${r.widgetId}`,
+      modeId: i,
+      resource: r.resource,
+      contributionId: r.contributionId,
+      instanceKey: r.widgetId,
+      title: r.title
+    },
+    selectedSubPanels: {},
+    kind: r.resource ? "resource" : "widget",
+    modeId: i,
+    resource: r.resource,
+    widgetId: r.widgetId,
+    contributionId: r.contributionId,
+    title: r.title,
+    closedSubPanel: t
+  };
+}, ve = 1, Z = () => ({
+  entries: [],
+  cursor: -1,
+  recentlyClosed: [],
+  hydrating: !1
+}), Xe = (e) => {
+  if (e?.version !== ve) return Z();
+  const t = _(e.entries);
+  return {
+    entries: t,
+    cursor: Math.min(Math.max(e.cursor, t.length > 0 ? 0 : -1), t.length - 1),
+    recentlyClosed: e.recentlyClosed.slice(-20),
+    hydrating: !1
+  };
+}, ie = (e) => {
+  const {
+    entry: t,
+    layout: s,
+    modes: n,
+    resources: i
+  } = e;
+  if (t.closedSubPanel && s.getWidget(t.closedSubPanel.reference.contributionId)?.role !== "sub-panel")
+    return;
+  const r = t.contributionId ? s.getWidget(t.contributionId) : void 0;
+  if (!(t.kind === "mode" ? !!(t.modeId && n?.getMode(t.modeId)) : !!(r && r.role !== "panel-menu" && r.role !== "sub-panel" || t.resource && i.listPresenters().some((u) => u.canOpen(t.resource))))) return;
+  const c = Object.fromEntries(Object.entries(t.selectedSubPanels).filter(([, u]) => (u ? s.getWidget(u.contributionId) : void 0)?.role === "sub-panel"));
+  return {
+    ...t,
+    selectedSubPanels: c
+  };
+}, Ze = (e) => {
+  const {
+    state: t
+  } = e, s = t.entries[t.cursor]?.entryId, n = _(t.entries.map((c) => ie({
+    ...e,
+    entry: c
+  })).filter((c) => !!c)), i = s ? n.findIndex((c) => c.entryId === s) : -1, r = i >= 0 ? i : Math.min(t.cursor, n.length - 1), o = t.recentlyClosed.map((c) => ie({
+    ...e,
+    entry: c
+  })).filter((c) => !!c);
+  return {
+    ...t,
+    entries: n,
+    cursor: r,
+    recentlyClosed: o
+  };
+}, et = 50, tt = 50, rt = (e) => {
+  let t;
+  const s = () => {
+    if (t && clearTimeout(t), t = void 0, !e.persistence) return;
+    const {
+      hydrating: n,
+      ...i
+    } = e.store.getState();
+    e.persistence.setHistory({
+      ...i,
+      version: ve
+    }, e.getScope());
+  };
+  return {
+    flush: s,
+    schedule() {
+      !e.persistence || t || (t = setTimeout(s, tt));
+    }
+  };
+}, nt = (e, t, s, n) => n ? s ? t?.kind === "mode" ? !0 : e?.location.resource?.uri === t?.location.resource?.uri : t?.kind !== "mode" : !1, st = (e) => e.entries[e.cursor], ae = (e) => {
+  const t = /* @__PURE__ */ new Map();
+  for (const s of Object.values(e.getLayout().regions))
+    for (const n of s.widgets) t.set(n.widgetId, {
+      placement: n,
+      region: s.id
+    });
+  return t;
+}, ot = (e) => {
+  const {
+    entry: t,
+    layout: s,
+    placement: n,
+    replayCurrentLocation: i,
+    replayResource: r,
+    resource: o,
+    resources: c,
+    restoreSelections: u
+  } = e, f = Object.values(c.store.getState().presenters).find((a) => a.canOpen(o)), m = B(s.getLayout())?.resourceUri;
+  if (f && (i || m !== o.uri))
+    return r(t, n === void 0);
+  n?.resourceUri === o.uri ? s.activateWidget(n.widgetId) : t.contributionId && s.getWidget(t.contributionId)?.role === "location" ? s.openWidget(t.contributionId, {
+    resource: o,
+    title: t.title,
+    replaceActive: !!n
+  }) : n ? s.activateWidget(n.widgetId) : t.contributionId && s.getWidget(t.contributionId) && s.openWidget(t.contributionId, {
+    title: t.title
+  }), u(t);
+}, it = (e) => {
+  const {
+    activateEntry: t,
+    controllerInput: s,
+    finishRestore: n,
+    flush: i,
+    getPersistenceScope: r,
+    moveCursor: o,
+    runSilent: c,
+    setPersistenceScope: u,
+    setState: f,
+    store: m
+  } = e;
+  return {
+    store: m,
+    goBack: () => o(-1),
+    goForward: () => o(1),
+    goPrevious() {
+      const a = m.getState();
+      if (a.hydrating) return;
+      const d = a.entries[a.cursor];
+      for (let l = a.entries.length - 1; l >= 0; l -= 1) {
+        const b = a.entries[l];
+        if (!q(b, d))
+          return f({
+            ...a,
+            cursor: l
+          }, "history.goPrevious"), c(() => t(b)), b;
+      }
+    },
+    recentlyClosed: () => m.getState().recentlyClosed,
+    reopenLastClosed() {
+      const a = m.getState();
+      if (a.hydrating) return;
+      const d = a.recentlyClosed.at(-1);
+      if (d)
+        return f({
+          ...a,
+          recentlyClosed: a.recentlyClosed.slice(0, -1)
+        }, "history.reopenClosed"), c(() => {
+          const l = t(d), b = () => {
+            d.closedSubPanel && s.layout.openWidget(d.closedSubPanel.reference.contributionId, {
+              region: d.closedSubPanel.region,
+              resource: d.closedSubPanel.resource,
+              title: d.closedSubPanel.title,
+              closable: !0
+            });
+          };
+          l instanceof Promise ? l.then(b) : b();
+        }), d;
+    },
+    setPersistenceScope: u,
+    getPersistenceScope: r,
+    restore() {
+      const a = Ze({
+        state: m.getState(),
+        layout: s.layout,
+        modes: s.modes,
+        resources: s.resources
+      });
+      f(a, "history.reconcile");
+      const d = a.entries[a.cursor], l = r();
+      let b;
+      return d && c(() => {
+        const v = t(d, {
+          replayCurrentLocation: !0
+        });
+        v instanceof Promise && (b = v);
+      }), b ? b.then(() => n(l, d?.entryId), () => n(l, d?.entryId)) : n(l, d?.entryId), d;
+    },
+    flush: i,
+    clear() {
+      n(), f(Z(), "history.clear");
+    }
+  };
+}, at = (e) => {
+  const t = (s, n) => {
+    if (s !== void 0 && s !== e.getScope()) return;
+    const i = e.store.getState(), r = i.entries[i.cursor];
+    if (n && r && r.entryId !== n) {
+      let o;
+      e.runSilent(() => {
+        const c = e.activateEntry(r);
+        c instanceof Promise && (o = c);
+      }), o ? o.then(() => t(s, r.entryId), () => t(s, r.entryId)) : t(s, r.entryId);
+      return;
+    }
+    e.onFinish(), i.hydrating && e.setState({
+      ...i,
+      hydrating: !1
+    }, "history.finishRestore", !1);
+  };
+  return t;
+}, ct = (e) => (t) => {
+  const s = e.store.getState(), n = s.cursor + t, i = s.entries[n];
+  if (i)
+    return e.setState({
+      ...s,
+      cursor: n
+    }, t < 0 ? "history.goBack" : "history.goForward"), e.flush(), s.hydrating || e.runSilent(() => e.activateEntry(i)), i;
+}, dt = (e) => {
+  let t = !1;
+  return e.onWillChangePersistenceScope(() => {
+    t = !0;
+  }), e.onDidChangePersistenceScope(() => {
+    t = !1;
+  }), () => t;
+}, lt = (e) => {
+  const t = L({
+    name: "workbench.history",
+    initialState: Z()
+  });
+  let s = 0, n = !1, i = !1;
+  const r = dt(e.layout);
+  let o;
+  const c = /* @__PURE__ */ new Set(), {
+    flush: u,
+    schedule: f
+  } = rt({
+    persistence: e.persistence,
+    store: t,
+    getScope: () => o
+  }), m = (g, y, p = !0) => {
+    t.setState(g, !1, y), p && f();
+  }, a = (g) => {
+    if (!g) return;
+    const y = t.getState(), p = y.entries[y.cursor];
+    if (q(p, g)) return;
+    const w = y.entries.slice(0, y.cursor + 1), W = p?.kind === "mode" && g.kind !== "mode" && p.modeId === g.modeId, k = _(W ? [...w.slice(0, -1), g] : [...w, g]), x = k.slice(Math.max(0, k.length - (e.maxEntries ?? et)));
+    m({
+      ...y,
+      entries: x,
+      cursor: x.length - 1
+    }, "history.record");
+  }, d = (g = !1, y = !1) => {
+    if (n || i || r() || !y && e.resources.isOpeningResource()) return;
+    s += 1;
+    const w = Ye({
+      counter: s,
+      layout: e.layout,
+      modes: e.modes
+    }), W = st(t.getState());
+    nt(W, w, g, e.modes?.isTransitioning() ?? !1) || w?.location.resource && c.has(w.location.resource.uri) || a(w);
+  };
+  let l = ae(e.layout);
+  const b = (g) => {
+    const y = t.getState(), p = Y(e.layout, g);
+    if (p === "location" && e.resources.isOpeningResource()) return;
+    if (p !== "sub-panel") {
+      if (e.modes?.isTransitioning() || !e.layout.getWidget(g.contributionId)) return;
+      const x = _(y.entries.filter((V) => V.widgetId !== g.widgetId));
+      if (x.length === y.entries.length) return;
+      m({
+        ...y,
+        entries: x,
+        cursor: Math.min(y.cursor, x.length - 1)
+      }, "history.prune");
+      return;
+    }
+    const w = y.entries[y.cursor]?.entryId, W = _(y.entries.map((x) => Ge(x, g))), k = w ? W.findIndex((x) => x.entryId === w) : -1;
+    m({
+      ...y,
+      entries: W,
+      cursor: k >= 0 ? k : Math.min(y.cursor, W.length - 1)
+    }, "history.removeSubPanel");
+  }, v = (g, y) => {
+    s += 1;
+    const p = t.getState(), w = Y(e.layout, g), W = Je({
+      placement: g,
+      counter: s,
+      current: w === "sub-panel" ? p.entries[p.cursor] : void 0,
+      modeId: e.modes?.getActiveModeId(),
+      closedSubPanel: w === "sub-panel" && K.includes(y) ? {
+        region: y,
+        reference: {
+          contributionId: g.contributionId,
+          resourceUri: g.resourceUri,
+          instanceKey: g.widgetId
+        },
+        resource: g.resource,
+        title: g.title
+      } : void 0
+    }), k = [...p.recentlyClosed.filter((x) => !q(x, W)), W].slice(-20);
+    m({
+      ...p,
+      recentlyClosed: k
+    }, "history.recordClosed");
+  };
+  e.layout.store.subscribeSelector((g) => g.layout, () => {
+    const g = ae(e.layout);
+    if (i || r()) {
+      l = g;
+      return;
+    }
+    for (const [y, p] of l)
+      g.has(y) || (p.placement.closable && v(p.placement, p.region), b(p.placement));
+    l = g, d(!0);
+  }), e.modes?.onDidChangeActive(d), e.resources.onDidOpenResource(() => d(!1, !0));
+  const I = (g) => {
+    for (const y of X) {
+      const p = g.selectedSubPanels[y], w = p ? _e(e.layout, p) : void 0;
+      if (w) {
+        e.layout.activateWidget(w.widgetId);
+        continue;
+      }
+      const W = y === "main" ? e.layout.getLayout().activeLocationWidgetId : void 0;
+      e.layout.setRegionActiveWidget(y, W);
+    }
+  }, S = (g) => {
+    e.modes && e.modes.getActiveModeId() !== g.modeId && e.modes.setActiveMode(g.modeId);
+  }, h = (g, y, p) => {
+    const w = g.resource;
+    return c.add(w.uri), e.resources.openResource(w, {
+      replaceActive: p
+    }).finally(() => {
+      y === o && I(g), c.delete(w.uri);
+    });
+  }, R = (g, y = {}) => {
+    const p = o;
+    if (S(g), g.kind === "mode") {
+      I(g);
+      return;
+    }
+    const w = g.widgetId ? $(e.layout.getLayout(), g.widgetId)?.placement : void 0;
+    if (g.kind === "resource" && g.resource)
+      return ot({
+        entry: g,
+        resource: g.resource,
+        placement: w,
+        layout: e.layout,
+        resources: e.resources,
+        replayCurrentLocation: y.replayCurrentLocation,
+        replayResource: (W, k) => h(W, p, k),
+        restoreSelections: I
+      });
+    w ? e.layout.activateWidget(w.widgetId) : g.contributionId && e.layout.getWidget(g.contributionId) && e.layout.openWidget(g.contributionId, {
+      title: g.title
+    }), I(g);
+  }, C = (g) => {
+    n = !0;
+    try {
+      g();
+    } finally {
+      n = !1;
+    }
+  }, T = ct({
+    store: t,
+    activateEntry: R,
+    flush: u,
+    runSilent: C,
+    setState: m
+  }), M = (g) => {
+    if (g === o) return;
+    u(), o = g;
+    const y = Xe(e.persistence?.getHistory(g));
+    i = y.entries.length > 0, m({
+      ...y,
+      hydrating: i
+    }, "history.setPersistenceScope", !1);
+  };
+  typeof window < "u" && window.addEventListener("pagehide", u);
+  const H = at({
+    store: t,
+    activateEntry: R,
+    getScope: () => o,
+    onFinish: () => {
+      i = !1;
+    },
+    runSilent: C,
+    setState: m
+  });
+  return it({
+    controllerInput: e,
+    store: t,
+    finishRestore: H,
+    setPersistenceScope: M,
+    getPersistenceScope: () => o,
+    activateEntry: R,
+    moveCursor: T,
+    runSilent: C,
+    setState: m,
+    flush: u
+  });
+}, ut = (e) => {
+  const t = () => e.persistence?.getLastResource();
+  return {
+    get: t,
+    set: (i) => e.persistence?.setLastResource(i),
+    restore: async () => {
+      const i = t();
+      if (!i) return !1;
+      try {
+        return await e.openResource(i), !0;
+      } catch {
+        return !1;
+      }
+    }
+  };
+}, gt = (e = {}) => {
+  let t;
+  const s = Object.fromEntries(Object.entries(e.defaultOpenByRegionId ?? {}).filter((u) => u[1] !== void 0)), n = e.persistence?.getPanelStates(t), i = (u) => ({
+    ...s,
+    ...u?.openByRegionId
+  }), r = L({
+    name: "workbench.panels",
+    initialState: {
+      openByRegionId: i(n)
+    }
+  }), o = () => {
+    e.persistence && e.persistence.setPanelStates({
+      openByRegionId: r.getState().openByRegionId
+    }, t);
+  }, c = (u) => r.getState().openByRegionId[u] ?? !0;
+  return {
+    store: r,
+    isOpen: c,
+    setOpen(u, f) {
+      const m = r.getState();
+      (m.openByRegionId[u] ?? !0) !== f && (r.setState({
+        openByRegionId: {
+          ...m.openByRegionId,
+          [u]: f
+        }
+      }, !1, "setPanelOpen"), o());
+    },
+    toggle(u) {
+      this.setOpen(u, !c(u));
+    },
+    setPersistenceScope(u) {
+      if (u === t) return;
+      o(), t = u;
+      const f = e.persistence?.getPanelStates(t);
+      r.setState({
+        openByRegionId: i(f)
+      }, !1, "setPersistenceScope");
+    },
+    getPersistenceScope: () => t,
+    onDidChange(u) {
+      const f = r.subscribe((m) => u(m));
+      return P(f);
+    }
+  };
+}, ft = (e = {}) => {
+  const t = L({
+    name: "workbench.sidePanel",
+    initialState: {
+      mode: e.initialMode ?? "floating"
+    }
+  });
+  return {
+    store: t,
+    getMode() {
+      return t.getState().mode;
+    },
+    setMode(s) {
+      t.getState().mode !== s && t.setState({
+        mode: s
+      }, !1, "setMode");
+    },
+    onDidChange(s) {
+      const n = t.subscribeSelector((i) => i.mode, (i) => s(i));
+      return P(n);
+    }
+  };
+}, mt = "Terminal", ht = 200, yt = () => {
+  const e = L({
+    name: "workbench.terminal",
+    initialState: {
+      sessionsById: {}
+    }
+  });
+  let t = null;
+  const s = /* @__PURE__ */ new Map(), n = /* @__PURE__ */ new Map(), i = /* @__PURE__ */ new Map(), r = /* @__PURE__ */ new Set(), o = (a, d, l) => {
+    const b = e.getState(), v = b.sessionsById[a];
+    v && e.setState({
+      sessionsById: {
+        ...b.sessionsById,
+        [a]: {
+          ...v,
+          ...d
+        }
+      }
+    }, !1, l);
+  }, c = (a) => {
+    const d = s.get(a);
+    if (!d) throw new Error(`Unknown terminal session: ${a}`);
+    return d;
+  }, u = (a) => {
+    s.delete(a), i.delete(a), r.delete(a);
+    const d = n.get(a) ?? [];
+    n.delete(a);
+    for (const l of d) l();
+  }, f = (a, d) => {
+    if (r.has(a)) return;
+    const l = i.get(a);
+    l && (l.push(d), l.length > ht && l.shift());
+  }, m = async (a) => {
+    await c(a.sessionId).kill(a.signal), o(a.sessionId, {
+      status: "killed"
+    }, "killTerminalSession"), u(a.sessionId);
+  };
+  return {
+    store: e,
+    isAvailable: () => t !== null,
+    setSessionOpener(a) {
+      t = a;
+    },
+    async open(a) {
+      if (!t) throw new Error("Terminal sessions are not available in this workbench host.");
+      const d = await t(a.request);
+      s.set(d.id, d), i.set(d.id, []);
+      const l = [d.onData((I) => f(d.id, I))], b = d.onTitle?.((I) => o(d.id, {
+        title: I
+      }, "terminalSessionTitleChanged"));
+      b && l.push(b), l.push(d.onExit((I) => {
+        e.getState().sessionsById[d.id]?.status === "running" && o(d.id, {
+          status: "exited",
+          exit: I
+        }, "terminalSessionExited"), u(d.id);
+      })), n.set(d.id, l);
+      const v = e.getState();
+      return e.setState({
+        sessionsById: {
+          ...v.sessionsById,
+          [d.id]: {
+            id: d.id,
+            title: a.title ?? mt,
+            status: "running"
+          }
+        }
+      }, !1, "openTerminalSession"), {
+        sessionId: d.id
+      };
+    },
+    write(a) {
+      c(a.sessionId).write(a.data);
+    },
+    resize(a) {
+      c(a.sessionId).resize(a.cols, a.rows);
+    },
+    kill: m,
+    subscribe(a, d) {
+      const l = c(a), b = [];
+      if (d.onData) {
+        const v = i.get(a) ?? [];
+        i.delete(a), r.add(a), b.push(l.onData(d.onData));
+        for (const I of v) d.onData(I);
+      }
+      return b.push(d.onExit ? l.onExit(d.onExit) : void 0, d.onError ? l.onError(d.onError) : void 0), () => {
+        for (const v of b) v?.();
+      };
+    },
+    getSession(a) {
+      return e.getState().sessionsById[a];
+    },
+    listSessions() {
+      return Object.values(e.getState().sessionsById);
+    },
+    async dispose() {
+      const a = Object.values(e.getState().sessionsById).filter((d) => d.status === "running");
+      await Promise.all(a.map((d) => m({
+        sessionId: d.id
+      })));
+      for (const d of Object.values(e.getState().sessionsById)) u(d.id);
+      s.clear();
+    }
+  };
+}, bt = () => {
+  const e = L({
+    name: "workbench.commandPaletteResources",
+    initialState: {
+      providers: {},
+      refreshToken: 0
+    }
+  });
+  return {
+    store: e,
+    registerProvider(t) {
+      const s = e.getState();
+      if (s.providers[t.id])
+        throw new Error(`Command palette resource provider already registered: ${t.id}`);
+      return e.setState({
+        ...s,
+        providers: {
+          ...s.providers,
+          [t.id]: t
+        }
+      }, !1, "registerProvider"), P(() => {
+        const n = e.getState();
+        if (n.providers[t.id] !== t) return;
+        const {
+          [t.id]: i,
+          ...r
+        } = n.providers;
+        e.setState({
+          ...n,
+          providers: r
+        }, !1, "unregisterProvider");
+      });
+    },
+    listProviders() {
+      return Object.values(e.getState().providers);
+    },
+    async queryProviders(t) {
+      const s = Object.values(e.getState().providers);
+      return Promise.all(s.map(async (n) => {
+        try {
+          const i = await n.query(t);
+          return {
+            providerId: n.id,
+            title: n.title,
+            results: i
+          };
+        } catch {
+          return {
+            providerId: n.id,
+            title: n.title,
+            results: []
+          };
+        }
+      }));
+    },
+    refresh() {
+      const t = e.getState();
+      e.setState({
+        ...t,
+        refreshToken: t.refreshToken + 1
+      }, !1, "refresh");
+    }
+  };
+}, St = (e = {}) => {
+  const t = L({
+    name: "workbench.commands",
+    initialState: {
+      commands: {}
+    }
+  }), s = /* @__PURE__ */ new Set(), n = (r) => {
+    const o = t.getState().commands[r];
+    if (!o) throw new Error(`Command not registered: ${r}`);
+    return o;
+  }, i = (r) => {
+    for (const o of s) o(r);
+  };
+  return {
+    store: t,
+    registerCommand(r, o, c) {
+      const u = t.getState();
+      if (u.commands[r.id]) throw new Error(`Command already registered: ${r.id}`);
+      const f = {
+        ...D(c),
+        command: r,
+        handler: o
+      };
+      return t.setState({
+        commands: {
+          ...u.commands,
+          [r.id]: f
+        }
+      }, !1, "registerCommand"), P(() => {
+        const m = t.getState();
+        if (m.commands[r.id] !== f) return;
+        const {
+          [r.id]: a,
+          ...d
+        } = m.commands;
+        t.setState({
+          commands: d
+        }, !1, "unregisterCommand");
+      });
+    },
+    getCommand(r) {
+      return t.getState().commands[r];
+    },
+    listCommands() {
+      return Object.values(t.getState().commands).sort(O);
+    },
+    isCommandEnabled(r, o) {
+      return n(r).handler.isEnabled?.(o) ?? !0;
+    },
+    isCommandVisible(r, o) {
+      const c = n(r);
+      return e.context?.matches(c.command.when) ? c.handler.isVisible?.(o) ?? !0 : !1;
+    },
+    isCommandToggled(r, o) {
+      return n(r).handler.isToggled?.(o) ?? !1;
+    },
+    async executeCommand(r, o, c) {
+      const u = n(r);
+      if (u.handler.isEnabled?.(o) === !1) {
+        const f = new Error(`Command is disabled: ${r}`);
+        throw i({
+          commandId: r,
+          args: o,
+          error: f
+        }), f;
+      }
+      try {
+        return await u.handler.execute(o, c);
+      } catch (f) {
+        throw i({
+          commandId: r,
+          args: o,
+          error: f
+        }), f;
+      }
+    },
+    onDidExecuteError(r) {
+      return s.add(r), P(() => {
+        s.delete(r);
+      });
+    }
+  };
+}, vt = (e) => {
+  const {
+    getLayout: t,
+    getWidgets: s,
+    getPlaceholder: n
+  } = e;
+  return {
+    getRegionSize(i) {
+      const r = t().regions[i].size, o = j(t().regions[i]), c = o ? s()[o.contributionId]?.regionSize : n(i)?.regionSize;
+      return r === void 0 ? c : {
+        ...c,
+        defaultPx: r
+      };
+    },
+    getRegionCollapsible(i) {
+      const r = j(t().regions[i]);
+      return r ? s()[r.contributionId]?.regionCollapsible ?? !0 : n(i)?.regionCollapsible ?? !0;
+    },
+    getRegionHeaderBorderBottom(i) {
+      const r = j(t().regions[i]);
+      return r ? s()[r.contributionId]?.headerBorderBottom ?? !0 : !0;
+    }
+  };
+}, pt = (e) => {
+  const {
+    getPlaceholders: t,
+    getWidgets: s
+  } = e;
+  return {
+    listPlaceholders: () => Object.values(t()).sort(O),
+    listWidgets: () => Object.values(s()).sort(O)
+  };
+}, Rt = (e) => {
+  const {
+    store: t,
+    getPlaceholders: s,
+    getWidgets: n,
+    persistLayout: i
+  } = e;
+  return {
+    registerPlaceholder(r, o) {
+      if (s()[r.region])
+        throw new Error(`Placeholder already registered: ${r.region}`);
+      const {
+        priority: c,
+        ...u
+      } = r, f = {
+        ...u,
+        ...D({
+          ...o,
+          priority: o?.priority ?? c
+        })
+      }, m = t.getState();
+      return t.setState({
+        ...m,
+        placeholders: {
+          ...m.placeholders,
+          [r.region]: f
+        }
+      }, !1, "registerPlaceholder"), P(() => {
+        const a = t.getState();
+        if (a.placeholders[r.region] !== f) return;
+        const {
+          [r.region]: d,
+          ...l
+        } = a.placeholders;
+        t.setState({
+          ...a,
+          placeholders: l
+        }, !1, "unregisterPlaceholder");
+      });
+    },
+    registerWidget(r, o) {
+      if (n()[r.id]) throw new Error(`Widget already registered: ${r.id}`);
+      const {
+        priority: c,
+        reuse: u,
+        singleton: f,
+        ...m
+      } = r, a = {
+        ...m,
+        role: r.role ?? "content",
+        reuse: u ?? "resource",
+        singleton: f ?? !0,
+        ...D({
+          ...o,
+          priority: o?.priority ?? c
+        })
+      }, d = t.getState();
+      return t.setState({
+        ...d,
+        widgets: {
+          ...d.widgets,
+          [r.id]: a
+        }
+      }, !1, "registerWidget"), P(() => {
+        const l = t.getState();
+        if (l.widgets[r.id] !== a) return;
+        const {
+          [r.id]: b,
+          ...v
+        } = l.widgets, I = ye(l.layout, r.id);
+        t.setState({
+          widgets: v,
+          layout: I
+        }, !1, "unregisterWidget"), i();
+      });
+    }
+  };
+}, G = (e, t, s = "end") => {
+  const n = [...e];
+  if (s === "start")
+    return n.unshift(t), n;
+  if (s === "end")
+    return n.push(t), n;
+  const i = "beforeWidgetId" in s ? s.beforeWidgetId : s.afterWidgetId, r = n.findIndex((o) => o.widgetId === i);
+  return r < 0 ? (n.push(t), n) : (n.splice(r + ("afterWidgetId" in s ? 1 : 0), 0, t), n);
+}, N = (e, t, s) => {
+  if (t.tabRetention !== "preview") return G(e, t, s);
+  const n = e.filter((i) => i.tabRetention !== "preview" && i.widgetId !== t.widgetId);
+  return G(n, t, "start");
+}, wt = (e, t, s) => {
+  const n = e.find((r) => r.widgetId === t);
+  if (!n) return e;
+  if (n.tabRetention === "preview")
+    throw new Error(`Preview widget cannot be reordered: ${t}`);
+  const i = e.filter((r) => r.widgetId !== t);
+  return G(i, n, s);
+}, pe = (e, t) => {
+  let s = e;
+  for (const i of Object.values(e.regions)) {
+    const r = i.widgets.filter(t);
+    if (r.length === 0) continue;
+    const o = j(i);
+    s = A(s, i.id, (c) => c.filter((u) => !t(u)), {
+      clearActiveWidget: o ? t(o) : !1
+    });
+    for (const c of r)
+      s = Ce(s, c.widgetId);
+  }
+  return s.activeWidgetId && Object.values(s.regions).flatMap((i) => i.widgets).find((i) => i.widgetId === s.activeWidgetId) || (s = {
+    ...s,
+    activeWidgetId: void 0,
+    activeResourceUri: void 0
+  }), s;
+}, Pt = (e, t) => pe(e, (s) => s.tabRetention === "preview" && (t === void 0 || s.ownerResourceUri !== t)), J = (e) => pe(e, (t) => t.tabRetention === "preview"), It = (e) => ({
+  updateWidgetPlacement(t, s) {
+    const n = e.getLayout();
+    for (const i of Object.values(n.regions)) {
+      const r = i.widgets.findIndex((f) => f.widgetId === t);
+      if (r < 0) continue;
+      const o = e.requireWidget(i.widgets[r].contributionId), c = U(i.widgets[r], o, s), u = A(n, i.id, (f) => f.map((m, a) => a === r ? c : m));
+      return e.setLayout(u), e.persistLayout(), c;
+    }
+    throw new Error(`Widget placement not found: ${t}`);
+  },
+  reorderWidget(t, s) {
+    const n = e.getLayout();
+    for (const i of Object.values(n.regions))
+      if (i.widgets.some((r) => r.widgetId === t)) {
+        e.setLayout(A(n, i.id, (r) => wt(r, t, s))), e.persistLayout();
+        return;
+      }
+    throw new Error(`Widget placement not found: ${t}`);
+  },
+  expirePreviewTabs(t) {
+    e.setLayout(Pt(e.getLayout(), t)), e.persistLayout();
+  },
+  activateWidget(t) {
+    const s = e.getLayout();
+    for (const n of Object.values(s.regions)) {
+      const i = n.widgets.find((r) => r.widgetId === t);
+      if (i) return e.applyAndActivate(s, n.id, i);
+    }
+    throw new Error(`Widget placement not found: ${t}`);
+  }
+}), Ct = (e, t) => {
+  const s = {
+    ...t.regions
+  };
+  for (const n of Object.values(e.regions)) {
+    const i = n.widgets.filter((c) => c.pinned && c.role === "content");
+    if (i.length === 0) continue;
+    const r = new Set(i.map((c) => c.contributionId)), o = t.regions[n.id];
+    s[n.id] = {
+      ...o,
+      widgets: [...i, ...o.widgets.filter((c) => !r.has(c.contributionId))],
+      activeWidgetId: o.activeWidgetId ?? i[0]?.widgetId
+    };
+  }
+  return {
+    ...t,
+    regions: s
+  };
+}, Wt = (e, t, s) => {
+  if (s.length === 0) return t;
+  const n = {
+    ...t.regions
+  };
+  for (const i of s) n[i] = e.regions[i];
+  return {
+    ...t,
+    regions: n
+  };
+}, ce = (e, t) => t ? Se(J(t), e) : Ae(e), de = () => {
+  const e = /* @__PURE__ */ new Set();
+  return {
+    notify(t) {
+      for (const s of e) s(t);
+    },
+    subscribe(t) {
+      return e.add(t), P(() => e.delete(t));
+    }
+  };
+}, kt = (e) => {
+  for (const t of e.widget.ownedPanelMenuIds ?? []) {
+    const s = e.requireWidget(t);
+    e.openWidget(t, {
+      pinned: !0,
+      resource: e.placement.resource,
+      title: s.region === "main-left-menu" ? e.placement.resource?.label : s.title
+    });
+  }
+}, Lt = (e, t, s) => {
+  if (!(!e.singleton && e.reuse === "none")) {
+    if (e.role === "sub-panel" || e.role === "panel-menu") {
+      const n = B(t)?.resourceUri;
+      for (const i of Object.values(t.regions)) {
+        const r = i.widgets.findIndex((o) => o.contributionId === e.id && o.ownerResourceUri === n && (!s.resource || o.resourceUri === s.resource.uri));
+        if (r >= 0) return {
+          regionId: i.id,
+          index: r,
+          placement: i.widgets[r]
+        };
+      }
+      return;
+    }
+    return e.singleton ? ee(t, e.id) : s.resource ? be(t, e.id, s.resource.uri) : ee(t, e.id);
+  }
+}, Et = (e, t, s, n) => {
+  const i = e.regions[t], r = s.role === "location" ? e.activeLocationWidgetId : i.activeWidgetId;
+  if (n.replaceWidgetId)
+    return i.widgets.findIndex((c) => c.widgetId === n.replaceWidgetId);
+  if (n.tabRetention === "preview")
+    return i.widgets.findIndex((c) => c.tabRetention === "preview");
+  if (!n.replaceActive) return -1;
+  const o = t === "main" && n.resource && e.activeLocationWidgetId ? e.activeLocationWidgetId : r;
+  return i.widgets.findIndex((c) => c.widgetId === o && !c.pinned);
+}, Tt = (e) => {
+  const {
+    getLayout: t,
+    requireWidget: s,
+    applyAndActivate: n
+  } = e, i = (m, a, d) => a.role !== "sub-panel" && a.role !== "panel-menu" ? m : {
+    ...m,
+    ownerResourceUri: B(d)?.resourceUri
+  }, r = (m, a, d) => {
+    const l = i(U(a.placement, m, d), m, t()), b = A(t(), a.regionId, (v) => {
+      const I = v.map((S, h) => h === a.index ? l : S);
+      return d.tabPosition ? N(I.filter((S) => S.widgetId !== l.widgetId), l, d.tabPosition) : I;
+    });
+    return n(b, a.regionId, l);
+  }, o = (m, a, d, l, b) => {
+    const v = i(U(l, m, b), m, t()), I = A(t(), a, (S) => {
+      const h = S.map((R, C) => C === d ? v : R);
+      return v.tabRetention !== "preview" ? h : N(h, v, "start");
+    });
+    return n(I, a, v);
+  }, c = (m, a, d, l, b) => {
+    if (b.tabRetention === "preview" && a.placement.tabRetention !== "preview")
+      return n(t(), a.regionId, a.placement);
+    if (a.regionId !== d) {
+      const S = i(U(a.placement, m, b), m, t()), h = A(t(), a.regionId, (C) => C.filter((T, M) => M !== a.index), {
+        clearActiveWidget: t().regions[a.regionId].activeWidgetId === a.placement.widgetId
+      }), R = A(h, d, (C) => {
+        if (l < 0) return N(C, S, b.tabPosition);
+        const T = [...C];
+        return T.splice(l, 1, S), S.tabRetention === "preview" ? N(T, S, "start") : T;
+      });
+      return n(R, d, S);
+    }
+    if (l < 0 || a.index === l)
+      return r(m, a, b);
+    const v = i(U(a.placement, m, b), m, t()), I = A(t(), d, (S) => N(S.map((h, R) => R === a.index ? v : h).filter((h, R) => R !== l && R !== a.index), v, b.tabPosition));
+    return n(I, d, v);
+  }, u = (m, a, d, l) => {
+    const b = We(t(), m.id), v = i(ke(b, m, l), m, t()), I = A(t(), a, (S) => {
+      if (d < 0) return N(S, v, l.tabPosition);
+      const h = [...S];
+      return h.splice(d, 1, v), v.tabRetention === "preview" ? N(h, v, "start") : h;
+    });
+    return n(I, a, v);
+  }, f = (m, a = {}) => {
+    const d = s(m), l = t(), b = a.region ?? d.region ?? d.fallbackRegion ?? "main", v = l.regions[b], I = Et(l, b, d, a), S = I >= 0 ? v.widgets[I] : void 0, h = !a.replaceWidgetId && a.tabRetention === "preview" && a.resource ? be(l, d.id, a.resource.uri) : void 0, R = a.replaceWidgetId && S ? void 0 : Lt(d, l, a);
+    let C;
+    return h ? C = n(l, h.regionId, h.placement) : R ? C = c(d, R, b, I, a) : S?.contributionId === d.id ? C = o(d, b, I, S, a) : C = u(d, b, I, a), kt({
+      openWidget: f,
+      placement: C,
+      requireWidget: s,
+      widget: d
+    }), n(t(), h?.regionId ?? b, C);
+  };
+  return {
+    openWidget: f
+  };
+}, xt = (e) => ({
+  getPanel(t) {
+    const s = e.getWidgets()[t];
+    return s ? re(s) : void 0;
+  },
+  listPanels: () => e.listWidgets().map(re),
+  listPanelInstances(t) {
+    return (t ? e.getLayout().regions[t].widgets : Object.values(e.getLayout().regions).flatMap((n) => n.widgets)).map(F);
+  },
+  getActivePanel(t) {
+    if (t) {
+      const i = e.getLayout().regions[t], r = i.widgets.find((o) => o.widgetId === i.activeWidgetId) ?? i.widgets[0];
+      return r ? F(r) : void 0;
+    }
+    const s = e.getLayout().activeWidgetId;
+    if (!s) return;
+    const n = $(e.getLayout(), s);
+    return n ? F(n.placement) : void 0;
+  },
+  openPanel(t, s = {}) {
+    if (!e.getWidgets()[t]) throw new Error(`Panel not registered: ${t}`);
+    return F(e.widgetOpeners.openWidget(t, te(s)));
+  },
+  updatePanel(t, s) {
+    if (!$(e.getLayout(), t))
+      throw new Error(`Panel instance not found: ${t}`);
+    return F(e.placementMethods.updateWidgetPlacement(t, te(s)));
+  },
+  reorderPanel(t, s) {
+    if (!$(e.getLayout(), t))
+      throw new Error(`Panel instance not found: ${t}`);
+    e.placementMethods.reorderWidget(t, s);
+  },
+  activatePanel(t) {
+    if (!$(e.getLayout(), t))
+      throw new Error(`Panel instance not found: ${t}`);
+    return F(e.placementMethods.activateWidget(t));
+  },
+  closePanel(t) {
+    const s = $(e.getLayout(), t);
+    if (!s) throw new Error(`Panel instance not found: ${t}`);
+    if (s.placement.closable !== !0) throw new Error(`Panel cannot be closed: ${t}`);
+    const n = Q(e.getLayout(), t);
+    if (!n) throw new Error(`Panel instance not found: ${t}`);
+    return e.setLayout(n.layout), e.persistLayout(), n.activePlacement ? F(n.activePlacement) : void 0;
+  }
+}), Mt = (e, t, s) => {
+  const {
+    side: n,
+    ...i
+  } = t, r = e.region, o = K.find((c) => c === e.fallbackRegion);
+  return {
+    ...i,
+    region: se[r][n],
+    fallbackRegion: o ? se[o][n] : void 0,
+    panelMenuOwner: {
+      level: s === "sub-panel" ? "sub-panel" : "panel",
+      contributionId: e.id
+    },
+    role: "panel-menu"
+  };
+}, z = (e) => {
+  const {
+    closable: t,
+    metadata: s,
+    panel: n,
+    registerWidget: i,
+    role: r
+  } = e, {
+    panelMenus: o = [],
+    ...c
+  } = n, u = [];
+  if (o.length > 0 && !K.includes(n.region))
+    throw new Error(`Panel Menus require a Panel region: ${n.id}`);
+  try {
+    const f = {
+      ...c,
+      closable: t ?? r === "sub-panel",
+      ownedPanelMenuIds: o.map((m) => m.id),
+      role: r
+    };
+    u.push(i(f, s));
+    for (const m of o)
+      u.push(i(Mt(n, m, r), s));
+  } catch (f) {
+    for (const m of u.reverse()) m.dispose();
+    throw f;
+  }
+  return P(() => {
+    for (const f of u.reverse()) f.dispose();
+  });
+}, Dt = (e) => {
+  const t = (o) => o.eligibleLocations ? "sub-panel" : "content";
+  return {
+    registerPanel: (o, c) => z({
+      panel: o,
+      role: t(o),
+      closable: o.closable,
+      metadata: c,
+      registerWidget: e.registerWidget
+    }),
+    registerLocation: (o, c) => z({
+      panel: o,
+      role: "location",
+      metadata: c,
+      registerWidget: e.registerWidget
+    }),
+    registerSubPanel: (o, c) => z({
+      panel: o,
+      role: "sub-panel",
+      metadata: c,
+      registerWidget: e.registerWidget
+    }),
+    registerPanelMenu: (o, c) => e.registerWidget({
+      ...o,
+      role: "panel-menu"
+    }, c)
+  };
+}, Bt = (e) => (t) => {
+  const s = e.getLayout(), n = $(s, t);
+  if (!n) throw new Error(`Panel instance not found: ${t}`);
+  if (n.regionId !== "main") return e.panelMethods.activatePanel(t);
+  const i = {
+    ...n.placement,
+    role: "location"
+  }, r = new Set(e.getWidget(i.contributionId)?.ownedPanelMenuIds ?? []), o = Object.fromEntries(Object.entries(s.regions).map(([c, u]) => [c, {
+    ...u,
+    widgets: u.widgets.map((f) => f.widgetId === t ? i : !r.has(f.contributionId) || f.resourceUri !== i.resourceUri ? f : {
+      ...f,
+      ownerResourceUri: i.resourceUri
+    })
+  }]));
+  return e.applyAndActivate({
+    ...s,
+    regions: o
+  }, "main", i), e.panelMethods.getActivePanel("main");
+}, Ot = (e, t) => {
+  const s = e[t];
+  if (!s) throw new Error(`Widget not registered: ${t}`);
+  return s;
+}, At = (e = {}) => {
+  let t;
+  const s = de(), n = de(), i = e.persistence?.getLayout(t), r = ce(e.defaultRegionVisibility, i), o = L({
+    name: "workbench.layout",
+    initialState: {
+      layout: r,
+      widgets: {},
+      placeholders: {}
+    }
+  }), c = () => o.getState().layout, u = () => o.getState().placeholders, f = () => o.getState().widgets, m = (g) => u()[g], a = vt({
+    getLayout: c,
+    getWidgets: f,
+    getPlaceholder: m
+  }), d = pt({
+    getPlaceholders: u,
+    getWidgets: f
+  }), l = () => e.persistence?.setLayout(J(c()), t), b = (g) => Ot(f(), g), v = (g) => {
+    const y = o.getState();
+    y.layout !== g && o.setState({
+      ...y,
+      layout: g
+    }, !1, "setLayout");
+  }, I = (g, y) => {
+    const p = c(), w = p.regions[g], W = y(w);
+    W !== w && (v({
+      ...p,
+      regions: {
+        ...p.regions,
+        [g]: W
+      }
+    }), l());
+  }, S = (g, y, p) => (v(Le(g, y, p)), l(), p), h = Rt({
+    store: o,
+    getPlaceholders: u,
+    getWidgets: f,
+    persistLayout: l
+  }), R = Dt({
+    registerWidget: h.registerWidget
+  }), C = Tt({
+    getLayout: c,
+    requireWidget: b,
+    applyAndActivate: S
+  }), T = It({
+    getLayout: c,
+    requireWidget: b,
+    setLayout: v,
+    persistLayout: l,
+    applyAndActivate: S
+  }), M = xt({
+    getLayout: c,
+    getWidgets: f,
+    listWidgets: d.listWidgets,
+    persistLayout: l,
+    placementMethods: T,
+    setLayout: v,
+    widgetOpeners: C
+  }), H = Bt({
+    applyAndActivate: S,
+    getLayout: c,
+    getWidget: b,
+    panelMethods: M
+  });
+  return {
+    store: o,
+    registerPlaceholder: h.registerPlaceholder,
+    registerWidget: h.registerWidget,
+    ...R,
+    unregisterWidget(g, y = {}) {
+      const p = o.getState();
+      if (!p.widgets[g]) return;
+      const {
+        [g]: w,
+        ...W
+      } = p.widgets, k = y.removePlacements === !1 ? p.layout : ye(p.layout, g);
+      o.setState({
+        ...p,
+        widgets: W,
+        layout: k
+      }, !1, "unregisterWidget"), y.persist !== !1 && l();
+    },
+    getWidget(g) {
+      return f()[g];
+    },
+    getPlaceholder: m,
+    getRegionSize: a.getRegionSize,
+    getRegionCollapsible: a.getRegionCollapsible,
+    getRegionHeaderBorderBottom: a.getRegionHeaderBorderBottom,
+    setRegionVisible(g, y) {
+      I(g, (p) => p.visible === y ? p : {
+        ...p,
+        visible: y
+      });
+    },
+    setRegionSize(g, y) {
+      I(g, (p) => p.size === y ? p : {
+        ...p,
+        size: y
+      });
+    },
+    listPlaceholders: d.listPlaceholders,
+    listWidgets: d.listWidgets,
+    ...M,
+    openWidget: C.openWidget,
+    ...T,
+    establishLocation: H,
+    setRegionActiveWidget(g, y) {
+      const p = c(), w = p.regions[g], W = y ? w.widgets.find((V) => V.widgetId === y) : void 0;
+      if (y && !W) throw new Error(`Widget placement not found in ${g}: ${y}`);
+      if (w.activeWidgetId === y) return;
+      const k = {
+        ...p,
+        activeWidgetId: p.activeWidgetId === w.activeWidgetId ? W?.widgetId : p.activeWidgetId,
+        activeResourceUri: p.activeWidgetId === w.activeWidgetId ? W?.resourceUri : p.activeResourceUri,
+        regions: {
+          ...p.regions,
+          [g]: {
+            ...w,
+            activeWidgetId: W?.widgetId
+          }
+        }
+      }, x = g !== "side" && K.includes(g) ? ne(k, B(k), g, W?.role === "sub-panel" ? W.widgetId : void 0) : k;
+      v(x), l();
+    },
+    closeWidget(g) {
+      const y = Q(c(), g);
+      if (!y) throw new Error(`Widget placement not found: ${g}`);
+      if (y.closedPlacement.closable !== !0) throw new Error(`Widget cannot be closed: ${g}`);
+      return v(y.layout), l(), y.activePlacement;
+    },
+    removeWidgetPlacement(g) {
+      const y = Q(c(), g);
+      if (y)
+        return v(y.layout), l(), y.activePlacement;
+    },
+    clearRegion(g) {
+      const y = c(), p = y.regions[g], w = p.activeWidgetId, W = {
+        ...y,
+        regions: {
+          ...y.regions,
+          [g]: {
+            ...p,
+            widgets: [],
+            activeWidgetId: void 0
+          }
+        }
+      };
+      let k = w && y.activeWidgetId === w ? {
+        ...W,
+        activeWidgetId: void 0,
+        activeResourceUri: void 0
+      } : W;
+      g !== "side" && K.includes(g) && (k = ne(k, B(k), g, void 0)), v(k), l();
+    },
+    resetRegions() {
+      const g = c(), y = {};
+      for (const [p, w] of Object.entries(g.regions))
+        y[p] = {
+          ...w,
+          widgets: [],
+          activeWidgetId: void 0
+        };
+      v({
+        regions: y,
+        locationSubPanelSelections: {},
+        activeWidgetId: void 0,
+        activeLocationWidgetId: void 0,
+        activeResourceUri: void 0
+      }), l();
+    },
+    getLayout: c,
+    restoreLayout(g) {
+      v(Se(g, e.defaultRegionVisibility)), l();
+    },
+    setPersistenceScope(g, y = {}) {
+      if (t === g) return;
+      e.persistence?.setLayout(J(c()), t), s.notify(g), t = g;
+      const p = e.persistence?.getLayout(t), w = ce(e.defaultRegionVisibility, p), W = Ct(c(), w), k = Wt(c(), W, y.carryRegionState ?? []), x = o.getState();
+      o.setState({
+        ...x,
+        layout: k
+      }, !1, "setPersistenceScope"), n.notify(t);
+    },
+    getPersistenceScope: () => t,
+    onWillChangePersistenceScope: s.subscribe,
+    onDidChangePersistenceScope: n.subscribe
+  };
+}, le = (e) => e.join("/"), $t = (e) => {
+  const t = L({
+    name: "workbench.menus",
+    initialState: {
+      itemsByPath: {}
+    }
+  });
+  return {
+    menuStore: t,
+    registerMenuItem(s, n, i) {
+      if (!e.commands.getCommand(n.commandId)) throw new Error(`Menu command not registered: ${n.commandId}`);
+      const r = le(s), o = {
+        ...D(i),
+        ...n,
+        path: s
+      }, c = t.getState(), u = c.itemsByPath[r] ?? [];
+      return t.setState({
+        itemsByPath: {
+          ...c.itemsByPath,
+          [r]: [...u, o]
+        }
+      }, !1, "registerMenuItem"), P(() => {
+        const f = t.getState(), m = f.itemsByPath[r] ?? [], a = m.filter((d) => d !== o);
+        a.length !== m.length && t.setState({
+          itemsByPath: {
+            ...f.itemsByPath,
+            [r]: a
+          }
+        }, !1, "unregisterMenuItem");
+      });
+    },
+    listMenuItems(s) {
+      return [...t.getState().itemsByPath[le(s)] ?? []].sort((n, i) => {
+        const r = n.order ?? 0, o = i.order ?? 0;
+        return r - o || O(n, i);
+      });
+    }
+  };
+}, ue = (e, t) => t.priority - e.priority || e.id.localeCompare(t.id), Ft = () => {
+  throw new Error("navigation.openTarget: no dispatcher available (configure resolveDispatcher)");
+}, Nt = async (e, t) => e.kind === "resource" ? t.openResource(e.resource, e.input) : e.kind === "panel" ? t.openPanel(e.panelId, e.input) : t.executeCommand(e.commandId, e.args), Kt = (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 === "panel" && t.canOpenPanel?.(e.panelId) === !1)
+    throw new Error(`Cannot open navigation Panel target: ${e.panelId}`);
+  if (e.kind === "command" && t.canExecuteCommand?.(e.commandId) === !1)
+    throw new Error(`Cannot open navigation command target: ${e.commandId}`);
+}, Ut = (e) => e.kind === "compound" ? e.targets : [e], jt = (e = {}) => {
+  const t = e.resolveDispatcher ?? Ft, s = L({
+    name: "workbench.navigation",
+    initialState: {
+      parsers: {},
+      navigators: {}
+    }
+  }), n = (r, o) => {
+    const {
+      [o]: c,
+      ...u
+    } = r;
+    return u;
+  }, i = {
+    store: s,
+    registerParser(r, o) {
+      const c = s.getState();
+      if (c.parsers[r.id]) throw new Error(`Navigation parser already registered: ${r.id}`);
+      const {
+        priority: u,
+        ...f
+      } = r, m = {
+        ...f,
+        ...D({
+          ...o,
+          priority: o?.priority ?? u
+        })
+      };
+      return s.setState({
+        ...c,
+        parsers: {
+          ...c.parsers,
+          [r.id]: m
+        }
+      }, !1, "registerParser"), P(() => {
+        const a = s.getState();
+        a.parsers[r.id] === m && s.setState({
+          ...a,
+          parsers: n(a.parsers, r.id)
+        }, !1, "unregisterParser");
+      });
+    },
+    listParsers() {
+      return Object.values(s.getState().parsers).sort(ue);
+    },
+    resolveLocation(r) {
+      const o = this.listParsers().find((c) => c.canParse(r));
+      if (!o) throw new Error(`No navigation parser registered for location: ${r}`);
+      return o.parse(r);
+    },
+    async openTarget(r) {
+      const o = t(), c = Ut(r), u = [];
+      for (const m of c) Kt(m, o);
+      const f = r.kind === "compound" ? o.createCheckpoint?.() : void 0;
+      try {
+        for (const m of c) {
+          const a = await Nt(m, o);
+          u.push(a);
+        }
+      } catch (m) {
+        throw f?.(), m;
+      }
+      return u;
+    },
+    async navigate(r) {
+      return i.openTarget(i.resolveLocation(r));
+    },
+    registerNavigator(r, o) {
+      const c = s.getState();
+      if (c.navigators[r.id]) throw new Error(`Resource navigator already registered: ${r.id}`);
+      const {
+        priority: u,
+        ...f
+      } = r, m = {
+        ...f,
+        ...D({
+          ...o,
+          priority: o?.priority ?? u
+        })
+      };
+      return s.setState({
+        ...c,
+        navigators: {
+          ...c.navigators,
+          [r.id]: m
+        }
+      }, !1, "registerNavigator"), P(() => {
+        const a = s.getState();
+        a.navigators[r.id] === m && s.setState({
+          ...a,
+          navigators: n(a.navigators, r.id)
+        }, !1, "unregisterNavigator");
+      });
+    },
+    listNavigators() {
+      return Object.values(s.getState().navigators).sort(ue);
+    },
+    createHref(r) {
+      const o = this.listNavigators().find((c) => c.createHref && c.canNavigate(r));
+      if (!o?.createHref) throw new Error(`No navigator href registered for resource kind: ${r.kind}`);
+      return o.createHref(r);
+    },
+    async navigateResource(r) {
+      const o = this.listNavigators().find((c) => c.canNavigate(r));
+      if (!o) throw new Error(`No navigator registered for resource kind: ${r.kind}`);
+      return await o.navigate(r);
+    }
+  };
+  return i;
+}, _t = () => {
+  const e = L({
+    name: "workbench.notifications",
+    initialState: {
+      notifications: {}
+    }
+  }), t = /* @__PURE__ */ new Set();
+  let s = 0;
+  const n = (i) => {
+    for (const r of t) r(i);
+  };
+  return {
+    store: e,
+    show(i, r) {
+      let o = i.id;
+      o || (s += 1, o = `workbench.notification.${s.toString()}`);
+      const c = {
+        ...D(r),
+        ...i,
+        id: o,
+        createdAt: i.createdAt ?? (/* @__PURE__ */ new Date()).toISOString()
+      }, u = e.getState();
+      return e.setState({
+        notifications: {
+          ...u.notifications,
+          [o]: c
+        }
+      }, !1, "showNotification"), n({
+        type: "show",
+        id: o,
+        notification: c
+      }), c;
+    },
+    dismiss(i) {
+      const r = e.getState();
+      if (!r.notifications[i]) return !1;
+      const {
+        [i]: o,
+        ...c
+      } = r.notifications;
+      return e.setState({
+        notifications: c
+      }, !1, "dismissNotification"), n({
+        type: "dismiss",
+        id: i
+      }), !0;
+    },
+    clear() {
+      const i = Object.keys(e.getState().notifications);
+      e.setState({
+        notifications: {}
+      }, !1, "clearNotifications");
+      for (const r of i) n({
+        type: "dismiss",
+        id: r
+      });
+    },
+    listNotifications() {
+      return Object.values(e.getState().notifications).sort((i, r) => r.createdAt.localeCompare(i.createdAt));
+    },
+    subscribe(i) {
+      return t.add(i), P(() => {
+        t.delete(i);
+      });
+    }
+  };
+}, ge = (e, t) => `${e}:${t.scope}:${t.scopeId ?? ""}`, Ht = () => {
+  const e = /* @__PURE__ */ new Map();
+  return {
+    getValue(t, s) {
+      return e.get(ge(t, s));
+    },
+    setValue(t, s, n) {
+      e.set(ge(t, n), s);
+    }
+  };
+}, qt = (e = {}) => {
+  const t = L({
+    name: "workbench.preferences",
+    initialState: {
+      schemas: {}
+    }
+  }), s = e.persistence ?? Ht();
+  return {
+    store: t,
+    registerSchema(n, i) {
+      const r = Object.keys(n.properties), o = t.getState();
+      for (const u of r)
+        if (o.schemas[u]) throw new Error(`Preference schema already registered: ${u}`);
+      const c = {};
+      for (const u of r) {
+        const f = n.properties[u];
+        f && (c[u] = {
+          ...f,
+          ownerId: i?.ownerId ?? "workbench.core",
+          source: i?.source ?? "module"
+        });
+      }
+      return t.setState({
+        schemas: {
+          ...o.schemas,
+          ...c
+        }
+      }, !1, "registerSchema"), P(() => {
+        const f = {
+          ...t.getState().schemas
+        };
+        for (const m of r) delete f[m];
+        t.setState({
+          schemas: f
+        }, !1, "unregisterSchema");
+      });
+    },
+    getSchema(n) {
+      return t.getState().schemas[n];
+    },
+    setValue(n, i, r) {
+      if (!t.getState().schemas[n]) throw new Error(`Preference schema not registered: ${n}`);
+      s.setValue(n, i, r);
+    },
+    getValue(n, i) {
+      if (i) {
+        const o = s.getValue(n, i);
+        if (o !== void 0) return o;
+      }
+      const r = s.getValue(n, {
+        scope: "user"
+      });
+      return r !== void 0 ? r : t.getState().schemas[n]?.default;
+    }
+  };
+}, Vt = (e) => {
+  const {
+    rendererRegistry: t
+  } = e, s = L({
+    name: "workbench.controlsRenderers",
+    initialState: {
+      renderers: {}
+    }
+  }), n = /* @__PURE__ */ new Set();
+  let i = () => null;
+  const r = (o) => {
+    const c = s.getState().renderers[o];
+    if (!c) throw new Error(`Controls renderer not registered: ${o}`);
+    return c;
+  };
+  return {
+    controlsStore: s,
+    setControlsRendererImplementation(o) {
+      i = o;
+    },
+    registerControlsRenderer(o, c) {
+      const u = s.getState();
+      if (u.renderers[o.id])
+        throw new Error(`Controls renderer already registered: ${o.id}`);
+      const f = {
+        ...D(c),
+        ...o
+      };
+      s.setState({
+        ...u,
+        renderers: {
+          ...u.renderers,
+          [o.id]: f
+        }
+      }, !1, "registerControlsRenderer");
+      const m = t.registerRenderer({
+        id: o.id,
+        render: (a) => i({
+          ...a,
+          controlsRendererId: o.id
+        })
+      });
+      return P(() => {
+        m.dispose();
+        const a = s.getState();
+        if (a.renderers[o.id] !== f) return;
+        const {
+          [o.id]: d,
+          ...l
+        } = a.renderers;
+        s.setState({
+          renderers: l
+        }, !1, "unregisterControlsRenderer");
+      });
+    },
+    getControlsRenderer(o) {
+      return s.getState().renderers[o];
+    },
+    listControlsRenderers() {
+      return Object.values(s.getState().renderers).sort(O);
+    },
+    refreshControlsRenderer(o) {
+      r(o);
+      const c = {
+        controlsRendererId: o
+      };
+      for (const u of n) u(c);
+    },
+    onDidRefreshControlsRenderer(o) {
+      return n.add(o), P(() => {
+        n.delete(o);
+      });
+    }
+  };
+}, zt = (e) => {
+  const t = L({
+    name: "workbench.dataTableRenderers",
+    initialState: {
+      renderers: {}
+    }
+  }), s = /* @__PURE__ */ new Set();
+  let n = () => null;
+  return {
+    dataTableStore: t,
+    setDataTableRendererImplementation(i) {
+      n = i;
+    },
+    registerDataTableRenderer(i, r) {
+      const o = t.getState();
+      if (o.renderers[i.id])
+        throw new Error(`Data table renderer already registered: ${i.id}`);
+      const c = {
+        ...D(r),
+        ...i
+      };
+      t.setState({
+        renderers: {
+          ...o.renderers,
+          [i.id]: c
+        }
+      }, !1, "registerDataTableRenderer");
+      const u = e.rendererRegistry.registerRenderer({
+        id: i.id,
+        render: (f) => n({
+          ...f,
+          dataTableRendererId: i.id
+        })
+      });
+      return P(() => {
+        u.dispose();
+        const f = t.getState();
+        if (f.renderers[i.id] !== c) return;
+        const {
+          [i.id]: m,
+          ...a
+        } = f.renderers;
+        t.setState({
+          renderers: a
+        }, !1, "unregisterDataTableRenderer");
+      });
+    },
+    getDataTableRenderer(i) {
+      return t.getState().renderers[i];
+    },
+    listDataTableRenderers() {
+      return Object.values(t.getState().renderers).sort(O);
+    },
+    refreshDataTableRenderer(i) {
+      if (!t.getState().renderers[i]) throw new Error(`Data table renderer not registered: ${i}`);
+      const r = {
+        dataTableRendererId: i
+      };
+      for (const o of s) o(r);
+    },
+    onDidRefreshDataTableRenderer(i) {
+      return s.add(i), P(() => s.delete(i));
+    }
+  };
+}, Qt = (e) => {
+  const {
+    rendererRegistry: t
+  } = e, s = L({
+    name: "workbench.fileRenderers",
+    initialState: {
+      renderers: {}
+    }
+  }), n = /* @__PURE__ */ new Set();
+  let i = () => null;
+  const r = (o) => {
+    const c = s.getState().renderers[o];
+    if (!c) throw new Error(`File renderer not registered: ${o}`);
+    return c;
+  };
+  return {
+    fileRendererStore: s,
+    setFileRendererImplementation(o) {
+      i = o;
+    },
+    registerFileRenderer(o, c) {
+      const u = s.getState();
+      if (u.renderers[o.id]) throw new Error(`File renderer already registered: ${o.id}`);
+      const f = {
+        ...D(c),
+        ...o
+      };
+      s.setState({
+        ...u,
+        renderers: {
+          ...u.renderers,
+          [o.id]: f
+        }
+      }, !1, "registerFileRenderer");
+      const m = t.registerRenderer({
+        id: o.id,
+        render: (a) => i({
+          ...a,
+          fileRendererId: o.id
+        })
+      });
+      return P(() => {
+        m.dispose();
+        const a = s.getState();
+        if (a.renderers[o.id] !== f) return;
+        const {
+          [o.id]: d,
+          ...l
+        } = a.renderers;
+        s.setState({
+          renderers: l
+        }, !1, "unregisterFileRenderer");
+      });
+    },
+    getFileRenderer(o) {
+      return s.getState().renderers[o];
+    },
+    listFileRenderers() {
+      return Object.values(s.getState().renderers).sort(O);
+    },
+    refreshFileRenderer(o) {
+      r(o);
+      const c = {
+        fileRendererId: o
+      };
+      for (const u of n) u(c);
+    },
+    onDidRefreshFileRenderer(o) {
+      return n.add(o), P(() => {
+        n.delete(o);
+      });
+    }
+  };
+}, Yt = (e) => {
+  const {
+    rendererRegistry: t
+  } = e, s = L({
+    name: "workbench.kanbanRenderers",
+    initialState: {
+      renderers: {}
+    }
+  }), n = /* @__PURE__ */ new Set();
+  let i = () => null;
+  const r = (o) => {
+    const c = s.getState().renderers[o];
+    if (!c) throw new Error(`Kanban renderer not registered: ${o}`);
+    return c;
+  };
+  return {
+    dataStore: s,
+    setKanbanRendererImplementation(o) {
+      i = o;
+    },
+    registerKanbanRenderer(o, c) {
+      const u = s.getState();
+      if (u.renderers[o.id]) throw new Error(`Kanban renderer already registered: ${o.id}`);
+      const f = {
+        ...D(c),
+        ...o
+      };
+      s.setState({
+        ...u,
+        renderers: {
+          ...u.renderers,
+          [o.id]: f
+        }
+      }, !1, "registerKanbanRenderer");
+      const m = t.registerRenderer({
+        id: o.id,
+        render: (a) => i({
+          ...a,
+          kanbanRendererId: o.id
+        })
+      });
+      return P(() => {
+        m.dispose();
+        const a = s.getState();
+        if (a.renderers[o.id] !== f) return;
+        const {
+          [o.id]: d,
+          ...l
+        } = a.renderers;
+        s.setState({
+          renderers: l
+        }, !1, "unregisterKanbanRenderer");
+      });
+    },
+    getKanbanRenderer(o) {
+      return s.getState().renderers[o];
+    },
+    listKanbanRenderers() {
+      return Object.values(s.getState().renderers).sort(O);
+    },
+    refreshKanbanRenderer(o) {
+      r(o);
+      const c = {
+        kanbanRendererId: o
+      };
+      for (const u of n) u(c);
+    },
+    onDidRefreshKanbanRenderer(o) {
+      return n.add(o), P(() => {
+        n.delete(o);
+      });
+    }
+  };
+}, fe = (e) => ({
+  expandedNodeIds: [...e.defaultExpandedNodeIds ?? []],
+  expandedSectionIds: [...e.defaultExpandedSectionIds ?? []]
+}), Gt = (e, t) => {
+  const s = (t.defaultExpandedSectionIds ?? []).filter((n) => !e.expandedSectionIds.includes(n));
+  return s.length === 0 ? e : {
+    ...e,
+    expandedSectionIds: [...e.expandedSectionIds, ...s]
+  };
+}, me = (e, t, s) => s ? e.includes(t) ? e : [...e, t] : e.includes(t) ? e.filter((n) => n !== t) : e, Jt = (e) => {
+  const {
+    rendererRegistry: t,
+    persistence: s
+  } = e, n = s?.getTreeStates(), i = L({
+    name: "workbench.treeRenderers",
+    initialState: {
+      trees: {},
+      statesByTreeId: n?.statesByTreeId ?? {},
+      refreshKeysByTreeId: {}
+    }
+  }), r = /* @__PURE__ */ new Set();
+  let o = () => null;
+  const c = (a) => {
+    const d = i.getState().trees[a];
+    if (!d) throw new Error(`Tree renderer not registered: ${a}`);
+    return d;
+  }, u = (a) => {
+    const d = i.getState(), l = d.statesByTreeId[a];
+    if (l) return l;
+    const b = d.trees[a];
+    if (!b) throw new Error(`Tree renderer not registered: ${a}`);
+    const v = fe(b);
+    return i.setState({
+      ...d,
+      statesByTreeId: {
+        ...d.statesByTreeId,
+        [a]: v
+      }
+    }, !1, "ensureTreeState"), v;
+  }, f = () => {
+    if (!s) return;
+    const a = {};
+    for (const [d, l] of Object.entries(i.getState().statesByTreeId)) {
+      const {
+        loading: b,
+        ...v
+      } = l;
+      a[d] = v;
+    }
+    s.setTreeStates({
+      statesByTreeId: a
+    });
+  }, m = (a, d, l) => {
+    const b = u(a), v = d(b);
+    if (v === b) return;
+    const I = i.getState();
+    i.setState({
+      ...I,
+      statesByTreeId: {
+        ...I.statesByTreeId,
+        [a]: v
+      }
+    }, !1, l), f();
+  };
+  return {
+    treeStore: i,
+    setTreeRendererImplementation(a) {
+      o = a;
+    },
+    registerTreeRenderer(a, d) {
+      const l = i.getState();
+      if (l.trees[a.id]) throw new Error(`Tree renderer already registered: ${a.id}`);
+      const b = {
+        ...D(d),
+        ...a
+      }, v = l.statesByTreeId[a.id], I = v ? Gt(v, a) : fe(a);
+      i.setState({
+        ...l,
+        trees: {
+          ...l.trees,
+          [a.id]: b
+        },
+        statesByTreeId: {
+          ...l.statesByTreeId,
+          [a.id]: I
+        }
+      }, !1, "registerTreeRenderer");
+      const S = t.registerRenderer({
+        id: a.id,
+        render: (h) => o({
+          ...h,
+          treeId: a.id
+        })
+      });
+      return P(() => {
+        S.dispose();
+        const h = i.getState();
+        if (h.trees[a.id] !== b) return;
+        const {
+          [a.id]: R,
+          ...C
+        } = h.trees, {
+          [a.id]: T,
+          ...M
+        } = h.statesByTreeId, {
+          [a.id]: H,
+          ...g
+        } = h.refreshKeysByTreeId;
+        i.setState({
+          trees: C,
+          statesByTreeId: M,
+          refreshKeysByTreeId: g
+        }, !1, "unregisterTreeRenderer"), f();
+      });
+    },
+    getTreeRenderer(a) {
+      return i.getState().trees[a];
+    },
+    listTreeRenderers() {
+      return Object.values(i.getState().trees).sort(O);
+    },
+    async getBody(a, d = {}) {
+      return await c(a).getBody(d);
+    },
+    async getHeader(a, d = {}) {
+      const l = c(a);
+      return l.getHeader ? await l.getHeader(d) : [];
+    },
+    async getFooter(a, d = {}) {
+      const l = c(a);
+      return l.getFooter ? await l.getFooter(d) : [];
+    },
+    async getChildren(a, d, l = {}) {
+      return await c(a).getChildren(d, l);
+    },
+    getTreeState(a) {
+      const d = u(a);
+      return {
+        expandedNodeIds: [...d.expandedNodeIds],
+        expandedSectionIds: [...d.expandedSectionIds],
+        selectedNodeId: d.selectedNodeId,
+        loading: d.loading
+      };
+    },
+    setNodeExpanded(a, d, l) {
+      c(a), m(a, (b) => {
+        const v = me(b.expandedNodeIds, d, l);
+        return v === b.expandedNodeIds ? b : {
+          ...b,
+          expandedNodeIds: v
+        };
+      }, "setNodeExpanded");
+    },
+    setSectionExpanded(a, d, l) {
+      c(a), m(a, (b) => {
+        const v = me(b.expandedSectionIds, d, l);
+        return v === b.expandedSectionIds ? b : {
+          ...b,
+          expandedSectionIds: v
+        };
+      }, "setSectionExpanded");
+    },
+    setSelectedNode(a, d) {
+      c(a), m(a, (l) => l.selectedNodeId === d ? l : {
+        ...l,
+        selectedNodeId: d
+      }, "setSelectedNode");
+    },
+    setLoading(a, d) {
+      c(a);
+      const l = u(a);
+      if (l.loading === d) return;
+      const b = i.getState();
+      i.setState({
+        ...b,
+        statesByTreeId: {
+          ...b.statesByTreeId,
+          [a]: {
+            ...l,
+            loading: d
+          }
+        }
+      }, !1, "setLoading");
+    },
+    refresh(a) {
+      c(a);
+      const d = i.getState(), l = d.refreshKeysByTreeId[a] ?? 0;
+      i.setState({
+        ...d,
+        refreshKeysByTreeId: {
+          ...d.refreshKeysByTreeId,
+          [a]: l + 1
+        }
+      }, !1, "refreshTreeRenderer");
+      const b = {
+        treeId: a
+      };
+      for (const v of r) v(b);
+    },
+    onDidRefresh(a) {
+      return r.add(a), P(() => {
+        r.delete(a);
+      });
+    }
+  };
+}, he = (e, t) => (e.order ?? 0) - (t.order ?? 0) || O(e, t), Xt = () => {
+  const e = L({
+    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, s) {
+      const n = e.getState();
+      if (n.sections[t.id]) throw new Error(`Settings section already registered: ${t.id}`);
+      const i = {
+        ...D(s),
+        ...t
+      };
+      return e.setState({
+        ...n,
+        sections: {
+          ...n.sections,
+          [t.id]: i
+        }
+      }, !1, "registerSection"), P(() => {
+        const r = e.getState();
+        if (r.sections[t.id] !== i) return;
+        const {
+          [t.id]: o,
+          ...c
+        } = r.sections;
+        e.setState({
+          ...r,
+          sections: c
+        }, !1, "unregisterSection");
+      });
+    },
+    registerPanel(t, s) {
+      const n = e.getState();
+      if (n.panels[t.id]) throw new Error(`Settings panel already registered: ${t.id}`);
+      const i = {
+        ...D(s),
+        ...t
+      };
+      return e.setState({
+        ...n,
+        panels: {
+          ...n.panels,
+          [t.id]: i
+        }
+      }, !1, "registerPanel"), P(() => {
+        const r = e.getState();
+        if (r.panels[t.id] !== i) return;
+        const {
+          [t.id]: o,
+          ...c
+        } = r.panels;
+        e.setState({
+          ...r,
+          panels: c
+        }, !1, "unregisterPanel");
+      });
+    },
+    getSection(t) {
+      return e.getState().sections[t];
+    },
+    getPanel(t) {
+      return e.getState().panels[t];
+    },
+    listSections() {
+      return Object.values(e.getState().sections).sort(he);
+    },
+    listPanels() {
+      return Object.values(e.getState().panels).sort(he);
+    }
+  };
+}, Zt = () => {
+  const e = L({
+    name: "workbench.fileIconThemes",
+    initialState: {
+      themes: []
+    }
+  }), t = /* @__PURE__ */ new Set(), s = () => {
+    e.setState({
+      themes: [...t].flat()
+    }, !1, "syncFileIconThemes");
+  };
+  return {
+    store: e,
+    register(n) {
+      return t.add(n), s(), P(() => {
+        t.delete(n) && s();
+      });
+    },
+    listThemes() {
+      return e.getState().themes;
+    }
+  };
+}, er = () => {
+  const e = L({
+    name: "workbench.themes",
+    initialState: {
+      themes: []
+    }
+  }), t = /* @__PURE__ */ new Set(), s = () => {
+    e.setState({
+      themes: [...t].flat()
+    }, !1, "syncThemes");
+  };
+  return {
+    store: e,
+    register(n) {
+      return t.add(n), s(), P(() => {
+        t.delete(n) && s();
+      });
+    },
+    listThemes() {
+      return e.getState().themes;
+    }
+  };
+}, tr = (e) => (t) => e.listProviders().some((n) => n.kind === t.kind) ? e.listResources("").some((n) => n.resource.uri === t.uri) : !0, rr = ({
+  layout: e,
+  isInScope: t
+}) => {
+  const s = e.store.subscribeSelector((n) => j(n.layout.regions[$e("primary")])?.resourceUri, () => {
+    const n = e.getLayout(), i = Ee(n, "primary");
+    for (const r of Te({
+      layout: n,
+      primary: i,
+      isInScope: t
+    }))
+      r.action === "clear" && e.clearRegion(r.region);
+  });
+  return P(s);
+}, nr = /* @__PURE__ */ new Set(["sidenav", "secondary", "main-left-menu", "main-right-menu", "secondary-left-menu", "secondary-right-menu", "side-left-menu", "side-right-menu"]), sr = (e) => nr.has(e), or = (e) => ({
+  getRegionState(t) {
+    const s = e.layout.getLayout().regions[t];
+    return {
+      open: s.visible,
+      size: s.size
+    };
+  },
+  setRegionOpen(t, s) {
+    e.layout.setRegionVisible(t, s);
+  },
+  setRegionSize(t, s) {
+    e.layout.setRegionSize(t, s);
+  },
+  getSidePanelPresentation: e.sidePanel.getMode,
+  setSidePanelPresentation: e.sidePanel.setMode,
+  onDidChange(t) {
+    const s = e.layout.store.subscribeSelector((i) => i.layout, t), n = e.sidePanel.onDidChange(t);
+    return P(() => {
+      s(), n.dispose();
+    });
+  }
+}), ir = "sidenav", ar = (e, t, s) => {
+  e.panels.setOpen(t, s), e.layout.setRegionVisible(t, s);
+}, cr = (e, t) => {
+  ar(e, t, !e.panels.isOpen(t));
+}, dr = [{
+  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 Sidenav",
+  icon: "PanelLeft",
+  keybinding: "Mod+B",
+  execute: (e) => cr(e, ir)
+}], lr = (e) => {
+  for (const t of dr)
+    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(oe, {
+      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(oe, {
+    commandId: "workbench.action.switchMode",
+    group: "Workbench"
+  });
+}, E = (e, t) => ({
+  ...t,
+  source: e.source,
+  ownerId: e.ownerId
+}), Re = (e) => e ? Array.isArray(e) ? [...e] : [e] : [], we = (e) => {
+  for (let t = e.length - 1; t >= 0; t -= 1)
+    e[t]?.dispose();
+}, Pe = (e, t) => {
+  const s = e.context.createScope(t.ownerId);
+  t.track(s);
+  const n = (r) => (t.track(r), r);
+  return {
+    ...e,
+    onDidChangePrimaryResource: (r) => n(e.onDidChangePrimaryResource(r)),
+    onDidChangeActiveResource: (r) => n(e.onDidChangeActiveResource(r)),
+    breadcrumbs: {
+      ...e.breadcrumbs,
+      setItems: (r) => n(e.breadcrumbs.setItems(r)),
+      onDidChange: (r) => n(e.breadcrumbs.onDidChange(r))
+    },
+    commandPalette: {
+      ...e.commandPalette,
+      onDidChange: (r) => n(e.commandPalette.onDidChange(r))
+    },
+    context: {
+      ...e.context,
+      set: (r, o) => s.set(r, o),
+      delete: (r) => s.delete(r),
+      createScope: (r) => n(e.context.createScope(r))
+    },
+    focus: {
+      ...e.focus,
+      onDidChange: (r) => n(e.focus.onDidChange(r))
+    },
+    commands: {
+      ...e.commands,
+      registerCommand: (r, o, c) => n(e.commands.registerCommand(r, o, E(t, c))),
+      onDidExecuteError: (r) => n(e.commands.onDidExecuteError(r))
+    },
+    keybindings: {
+      ...e.keybindings,
+      registerKeybinding: (r, o) => n(e.keybindings.registerKeybinding(r, E(t, o)))
+    },
+    lastResource: {
+      ...e.lastResource
+    },
+    layout: {
+      ...e.layout,
+      openPanel: (r, o) => {
+        const c = e.layout.openPanel(r, o);
+        return n(P(() => e.layout.removeWidgetPlacement(c.instanceId))), c;
+      },
+      openWidget: (r, o) => {
+        const c = e.layout.openWidget(r, {
+          ...o,
+          ownerId: t.ownerId,
+          source: t.source
+        });
+        return n(P(() => e.layout.removeWidgetPlacement(c.widgetId))), c;
+      },
+      registerPlaceholder: (r, o) => n(e.layout.registerPlaceholder(r, E(t, o))),
+      registerPanel: (r, o) => n(e.layout.registerPanel(r, E(t, o))),
+      registerWidget: (r, o) => n(e.layout.registerWidget(r, E(t, o))),
+      registerLocation: (r, o) => n(e.layout.registerLocation(r, E(t, o))),
+      registerSubPanel: (r, o) => n(e.layout.registerSubPanel(r, E(t, o))),
+      registerPanelMenu: (r, o) => n(e.layout.registerPanelMenu(r, E(t, o))),
+      registerMenuItem: (r, o, c) => n(e.layout.registerMenuItem(r, o, E(t, c))),
+      onWillChangePersistenceScope: (r) => n(e.layout.onWillChangePersistenceScope(r)),
+      onDidChangePersistenceScope: (r) => n(e.layout.onDidChangePersistenceScope(r))
+    },
+    modes: {
+      ...e.modes,
+      registerMode: (r) => n(e.modes.registerMode({
+        ...r,
+        activate: () => {
+          const o = [], c = Pe(e, {
+            ...t,
+            track: (f) => {
+              o.push(f);
+            }
+          }), u = Re(r.activate(c));
+          return P(() => we([...o, ...u]));
+        }
+      })),
+      onDidChangeActive: (r) => n(e.modes.onDidChangeActive(r))
+    },
+    navigation: {
+      ...e.navigation,
+      registerNavigator: (r, o) => n(e.navigation.registerNavigator(r, E(t, o))),
+      registerParser: (r, o) => n(e.navigation.registerParser(r, E(t, o)))
+    },
+    notifications: {
+      ...e.notifications,
+      show: (r, o) => e.notifications.show(r, E(t, o))
+    },
+    panels: {
+      ...e.panels,
+      onDidChange: (r) => n(e.panels.onDidChange(r))
+    },
+    preferences: {
+      ...e.preferences,
+      registerSchema: (r, o) => n(e.preferences.registerSchema(r, E(t, o)))
+    },
+    renderers: {
+      ...e.renderers,
+      registerRenderer: (r) => n(e.renderers.registerRenderer(r)),
+      registerTreeRenderer: (r, o) => n(e.renderers.registerTreeRenderer(r, E(t, o))),
+      registerKanbanRenderer: (r, o) => n(e.renderers.registerKanbanRenderer(r, E(t, o))),
+      registerDataTableRenderer: (r, o) => n(e.renderers.registerDataTableRenderer(r, E(t, o))),
+      registerFileRenderer: (r, o) => n(e.renderers.registerFileRenderer(r, E(t, o))),
+      registerControlsRenderer: (r, o) => n(e.renderers.registerControlsRenderer(r, E(t, o))),
+      onDidChange: (r) => n(e.renderers.onDidChange(r)),
+      onDidRefresh: (r) => n(e.renderers.onDidRefresh(r))
+    },
+    resources: {
+      ...e.resources,
+      registerKind: (r, o) => n(e.resources.registerKind(r, E(t, o))),
+      registerHierarchyProvider: (r) => n(e.resources.registerHierarchyProvider(r)),
+      registerPresenter: (r) => n(e.resources.registerPresenter(r)),
+      registerProvider: (r) => n(e.resources.registerProvider(r)),
+      onDidOpenResource: (r) => n(e.resources.onDidOpenResource(r))
+    },
+    settings: {
+      ...e.settings,
+      registerSection: (r, o) => n(e.settings.registerSection(r, E(t, o))),
+      registerPanel: (r, o) => n(e.settings.registerPanel(r, E(t, o)))
+    },
+    shell: {
+      ...e.shell,
+      onDidChange: (r) => n(e.shell.onDidChange(r))
+    },
+    sidePanel: {
+      ...e.sidePanel,
+      onDidChange: (r) => n(e.sidePanel.onDidChange(r))
+    },
+    themes: {
+      ...e.themes,
+      register: (r) => n(e.themes.register(r))
+    },
+    fileIconThemes: {
+      ...e.fileIconThemes,
+      register: (r) => n(e.fileIconThemes.register(r))
+    }
+  };
+}, yr = (e = {}) => {
+  const t = xe(), s = St({
+    context: t
+  }), n = /* @__PURE__ */ new Map(), i = Me(e.renderers), r = Jt({
+    rendererRegistry: i,
+    persistence: e.treePersistence
+  }), o = Yt({
+    rendererRegistry: i
+  }), c = zt({
+    rendererRegistry: i
+  }), u = Qt({
+    rendererRegistry: i
+  }), f = Vt({
+    rendererRegistry: i
+  }), m = At({
+    defaultRegionVisibility: e.defaultPanelOpenByRegionId,
+    persistence: e.persistence ? {
+      getLayout: (h) => e.persistence?.getSnapshot(h)?.layout,
+      setLayout: (h, R) => e.persistence?.setSnapshot({
+        layout: h
+      }, R),
+      flush: e.persistence.flush,
+      dispose: e.persistence.dispose
+    } : e.layoutPersistence
+  }), {
+    establishLocation: a,
+    ...d
+  } = m, l = {
+    ...d,
+    ...$t({
+      commands: s
+    })
+  }, b = je({
+    context: t,
+    isRegionFocusable: (h) => l.getLayout().regions[h].visible
+  }), v = ft({
+    initialMode: e.initialSidePanelMode
+  }), I = or({
+    layout: l,
+    sidePanel: v
+  }), S = {
+    breadcrumbs: Fe(),
+    commandPalette: Ne(),
+    commands: s,
+    context: t,
+    focus: b,
+    host: {
+      getSnapshot: () => ({
+        layout: l.getLayout()
+      }),
+      restoreSnapshot: (h) => l.restoreLayout(h.layout),
+      setPersistenceScope: (h, R = {}) => l.setPersistenceScope(h, {
+        carryRegionState: R.carryRegions
+      }),
+      getPersistenceScope: l.getPersistenceScope
+    },
+    history: void 0,
+    keybindings: Be({
+      commands: s,
+      context: t
+    }),
+    lastResource: ut({
+      persistence: e.lastResourcePersistence,
+      openResource: (h) => S.resources.openResource(h, {
+        replaceActive: !0
+      })
+    }),
+    layout: l,
+    modes: void 0,
+    notifications: _t(),
+    navigation: jt({
+      resolveDispatcher: () => ({
+        createCheckpoint: () => {
+          const h = S.layout.getLayout();
+          return () => S.layout.restoreLayout(h);
+        },
+        canOpenResource: (h) => {
+          const R = S.resources.store.getState();
+          return !!(R.kinds[h.kind] && Object.values(R.presenters).some((C) => C.canOpen(h)));
+        },
+        canOpenPanel: (h) => !!S.layout.getPanel(h),
+        canExecuteCommand: (h) => !!S.commands.getCommand(h),
+        openResource: (h, R) => S.resources.openResource(h, R),
+        openPanel: (h, R) => {
+          const C = S.layout.openPanel(h, R), T = S.layout.getPanel(h), M = R?.region ?? T?.region;
+          return M && (M === "side" ? S.shell.setSidePanelPresentation("attached") : sr(M) && S.shell.setRegionOpen(M, !0)), C;
+        },
+        executeCommand: (h, R) => S.commands.executeCommand(h, R)
+      })
+    }),
+    panels: gt({
+      defaultOpenByRegionId: e.defaultPanelOpenByRegionId,
+      persistence: e.panelsPersistence
+    }),
+    preferences: qt({
+      persistence: e.preferencePersistence
+    }),
+    renderers: {
+      ...i,
+      ...r,
+      ...o,
+      ...c,
+      ...u,
+      ...f
+    },
+    commandPaletteResources: bt(),
+    resources: De({
+      getPrimary: () => B(S.layout.getLayout())?.resource,
+      establishLocation: (h) => a(h.instanceId)
+    }),
+    settings: Xt(),
+    shell: I,
+    sidePanel: v,
+    terminal: yt(),
+    themes: er(),
+    fileIconThemes: Zt(),
+    getActiveResource() {
+      const h = S.layout.getLayout().activeWidgetId;
+      if (h)
+        for (const R of Object.values(S.layout.getLayout().regions)) {
+          const C = R.widgets.find((T) => T.widgetId === h);
+          if (C) return C.resource;
+        }
+    },
+    onDidChangeActiveResource(h) {
+      return P(S.layout.store.subscribeSelector((R) => R.layout.activeResourceUri, () => h(S.getActiveResource())));
+    },
+    getPrimaryResource() {
+      return B(S.layout.getLayout())?.resource;
+    },
+    onDidChangePrimaryResource(h) {
+      return P(S.layout.store.subscribeSelector((R) => B(R.layout)?.resourceUri, () => h(S.getPrimaryResource())));
+    },
+    registerModule(h) {
+      if (n.has(h.id)) throw new Error(`Workbench module already registered: ${h.id}`);
+      const R = [], C = {
+        disposable: void 0
+      };
+      C.disposable = P(() => {
+        n.get(h.id) === C && (n.delete(h.id), we(R));
+      }), n.set(h.id, C);
+      try {
+        const T = Pe(S, {
+          ownerId: h.ownerId ?? h.id,
+          source: h.source ?? "module",
+          track: (M) => {
+            R.push(M);
+          }
+        });
+        R.push(...Re(h.activate(T)));
+      } catch (T) {
+        throw C.disposable.dispose(), T;
+      }
+      return C.disposable;
+    },
+    unregisterModule(h) {
+      n.get(h)?.disposable.dispose();
+    }
+  };
+  return S.modes = Oe({
+    establishLocation: (h) => a(h),
+    resolveContext: () => S
+  }), S.history = lt({
+    layout: S.layout,
+    modes: S.modes,
+    resources: S.resources,
+    persistence: e.historyPersistence
+  }), S.layout.store.subscribe((h) => {
+    const R = S.focus.getActiveRegion();
+    R && !h.layout.regions[R].visible && S.focus.clearFocus();
+  }), S.layout.onDidChangePersistenceScope(() => {
+    const h = S.layout.getLayout();
+    for (const R of Object.values(h.regions))
+      S.panels.setOpen(R.id, R.visible);
+  }), S.onDidChangePrimaryResource((h) => {
+    h && S.lastResource.set(h);
+  }), rr({
+    layout: S.layout,
+    isInScope: e.isInScope ?? tr(S.resources)
+  }), lr(S), S;
+};
 export {
-  a as createCommandPaletteResourceRegistry,
-  t as createCommandRegistry,
-  S as createContextKeyService,
-  s as createControlsRendererRegistry,
-  o as createDataRendererRegistry,
-  z as createDefaultWorkbenchLayout,
-  c as createFileIconThemeRegistry,
-  n as createFileRendererRegistry,
-  i as createHistoryController,
-  T as createKeybindingRegistry,
-  h as createLayoutModel,
-  l as createMenuRegistry,
-  R as createNavigationRegistry,
-  g as createNotificationRegistry,
-  b as createPreferenceRegistry,
-  K as createResourceRegistry,
-  d as createSettingsRegistry,
-  u as createThemeRegistry,
-  y as createTreeRendererRegistry,
-  k as createWorkbenchBreadcrumbController,
-  C as createWorkbenchCommandPaletteController,
-  m as createWorkbenchCore,
-  P as createWorkbenchFocusController,
-  W as createWorkbenchLastResourceController,
-  w as createWorkbenchModeRegistry,
-  M as createWorkbenchPanelsController,
-  L as createWorkbenchRendererRegistry,
-  j as createWorkbenchResourceContextValues,
-  v as createWorkbenchSelectionResourceMetadata,
-  x as createWorkbenchSessionPanelController,
-  F as createWorkbenchStore,
-  f as createWorkbenchTerminalController,
-  G as getAnchorResource,
-  H as getKeybindingSteps,
-  J as getSurface,
-  I as getWorkbenchSelectionResourceUris,
-  re as headerLeadingMenuPath,
-  ae as headerTrailingMenuPath,
-  O as listAnchorAreas,
-  Q as listProjectionAreas,
-  X as listProjectionsReading,
-  D as matchesContextExpression,
-  Y as reconcileAnchors,
-  Z as resolveAnchorArea,
-  te as resourceContextMenuPath,
-  N as standardResourceIcons,
-  _ as surfaceMap,
-  se as workbenchAreaTabLeadingMenuPath,
-  $ as workbenchAreas,
+  hr as createResourceBreadcrumbItems,
+  yr as createWorkbenchCore,
+  vr as createWorkbenchResourceContextValues,
+  pr as createWorkbenchSelectionResourceMetadata,
+  Rr as getKeybindingSteps,
+  wr as getWorkbenchModePanelForRegion,
+  Pr as getWorkbenchSelectionResourceUris,
+  Mr as headerLeadingMenuPath,
+  Dr as headerTrailingMenuPath,
+  Ir as isWorkbenchModePanelAvailable,
+  Cr as matchesContextExpression,
+  $e as resolveAnchorRegion,
+  Br as resourceContextMenuPath,
+  Wr as standardResourceIcons,
   oe as workbenchCommandPaletteMenuPath,
-  p as workbenchFocusAreas,
-  U as workbenchResourceIdContextKey,
-  q as workbenchResourceKindContextKey,
-  B as workbenchResourceMetadataContextKey,
-  E as workbenchSelectionResourceUriMetadataKey,
-  ce as workbenchTopHeaderLeadingMenuPath,
-  ne as workbenchTopHeaderTrailingMenuPath
+  Or as workbenchRegionTabAddMenuPath,
+  Ar as workbenchRegionTabLeadingMenuPath,
+  kr as workbenchResourceIdContextKey,
+  Lr as workbenchResourceKindContextKey,
+  Er as workbenchResourceMetadataContextKey,
+  Tr as workbenchSelectionResourceUriMetadataKey,
+  $r as workbenchTopHeaderLeadingMenuPath,
+  Fr as workbenchTopHeaderTrailingMenuPath
 };
 //# sourceMappingURL=index.js.map