zudoku 0.3.0-dev.2 → 0.3.0-dev.20

package/lib/hook-FCY9-FHO.js

@@ -0,0 +1,24 @@
+import { u as e } from "./DevPortalProvider-CRKuwoXc.js";
+import { u as i } from "./state-Ds_OxRHP.js";
+const s = () => {
+  const { authentication: t } = e(), o = i(), n = typeof t < "u";
+  return {
+    isAuthEnabled: n,
+    isPending: o.isPending,
+    profile: o.profile,
+    isAuthenticated: o.profile,
+    login: async () => {
+      if (!n)
+        throw new Error("Authentication is not enabled.");
+      await t.login();
+    },
+    logout: async () => {
+      if (!n)
+        throw new Error("Authentication is not enabled.");
+      await t.logout(), window.location.href = "/";
+    }
+  };
+};
+export {
+  s as u
+};

package/lib/index-By9bEW57.js

@@ -0,0 +1,411 @@
+var W = (e) => {
+  throw TypeError(e);
+};
+var N = (e, t, s) => t.has(e) || W("Cannot " + s);
+var c = (e, t, s) => (N(e, t, "read from private field"), s ? s.call(e) : t.get(e)), b = (e, t, s) => t.has(e) ? W("Cannot add the same private member more than once") : t instanceof WeakSet ? t.add(e) : t.set(e, s), E = (e, t, s, n) => (N(e, t, "write to private field"), n ? n.call(e, s) : t.set(e, s), s), C = (e, t, s) => (N(e, t, "access private method"), s);
+import { H as L, I as Z, n as q } from "./DevPortalProvider-CRKuwoXc.js";
+import * as r from "react";
+import { j as P } from "./index-PyGcnQFX.js";
+import * as z from "react-dom";
+var y, h, w, x, S, k, ct = (k = class extends L {
+  constructor(t) {
+    super();
+    b(this, x);
+    b(this, y);
+    b(this, h);
+    b(this, w);
+    this.mutationId = t.mutationId, E(this, h, t.mutationCache), E(this, y, []), this.state = t.state || J(), this.setOptions(t.options), this.scheduleGc();
+  }
+  setOptions(t) {
+    this.options = t, this.updateGcTime(this.options.gcTime);
+  }
+  get meta() {
+    return this.options.meta;
+  }
+  addObserver(t) {
+    c(this, y).includes(t) || (c(this, y).push(t), this.clearGcTimeout(), c(this, h).notify({
+      type: "observerAdded",
+      mutation: this,
+      observer: t
+    }));
+  }
+  removeObserver(t) {
+    E(this, y, c(this, y).filter((s) => s !== t)), this.scheduleGc(), c(this, h).notify({
+      type: "observerRemoved",
+      mutation: this,
+      observer: t
+    });
+  }
+  optionalRemove() {
+    c(this, y).length || (this.state.status === "pending" ? this.scheduleGc() : c(this, h).remove(this));
+  }
+  continue() {
+    var t;
+    return ((t = c(this, w)) == null ? void 0 : t.continue()) ?? // continuing a mutation assumes that variables are set, mutation must have been dehydrated before
+    this.execute(this.state.variables);
+  }
+  async execute(t) {
+    var o, i, u, a, l, d, g, p, m, R, v, j, M, $, I, A, _, F, G, V;
+    E(this, w, Z({
+      fn: () => this.options.mutationFn ? this.options.mutationFn(t) : Promise.reject(new Error("No mutationFn found")),
+      onFail: (f, O) => {
+        C(this, x, S).call(this, { type: "failed", failureCount: f, error: O });
+      },
+      onPause: () => {
+        C(this, x, S).call(this, { type: "pause" });
+      },
+      onContinue: () => {
+        C(this, x, S).call(this, { type: "continue" });
+      },
+      retry: this.options.retry ?? 0,
+      retryDelay: this.options.retryDelay,
+      networkMode: this.options.networkMode,
+      canRun: () => c(this, h).canRun(this)
+    }));
+    const s = this.state.status === "pending", n = !c(this, w).canStart();
+    try {
+      if (!s) {
+        C(this, x, S).call(this, { type: "pending", variables: t, isPaused: n }), await ((i = (o = c(this, h).config).onMutate) == null ? void 0 : i.call(
+          o,
+          t,
+          this
+        ));
+        const O = await ((a = (u = this.options).onMutate) == null ? void 0 : a.call(u, t));
+        O !== this.state.context && C(this, x, S).call(this, {
+          type: "pending",
+          context: O,
+          variables: t,
+          isPaused: n
+        });
+      }
+      const f = await c(this, w).start();
+      return await ((d = (l = c(this, h).config).onSuccess) == null ? void 0 : d.call(
+        l,
+        f,
+        t,
+        this.state.context,
+        this
+      )), await ((p = (g = this.options).onSuccess) == null ? void 0 : p.call(g, f, t, this.state.context)), await ((R = (m = c(this, h).config).onSettled) == null ? void 0 : R.call(
+        m,
+        f,
+        null,
+        this.state.variables,
+        this.state.context,
+        this
+      )), await ((j = (v = this.options).onSettled) == null ? void 0 : j.call(v, f, null, t, this.state.context)), C(this, x, S).call(this, { type: "success", data: f }), f;
+    } catch (f) {
+      try {
+        throw await (($ = (M = c(this, h).config).onError) == null ? void 0 : $.call(
+          M,
+          f,
+          t,
+          this.state.context,
+          this
+        )), await ((A = (I = this.options).onError) == null ? void 0 : A.call(
+          I,
+          f,
+          t,
+          this.state.context
+        )), await ((F = (_ = c(this, h).config).onSettled) == null ? void 0 : F.call(
+          _,
+          void 0,
+          f,
+          this.state.variables,
+          this.state.context,
+          this
+        )), await ((V = (G = this.options).onSettled) == null ? void 0 : V.call(
+          G,
+          void 0,
+          f,
+          t,
+          this.state.context
+        )), f;
+      } finally {
+        C(this, x, S).call(this, { type: "error", error: f });
+      }
+    } finally {
+      c(this, h).runNext(this);
+    }
+  }
+}, y = new WeakMap(), h = new WeakMap(), w = new WeakMap(), x = new WeakSet(), S = function(t) {
+  const s = (n) => {
+    switch (t.type) {
+      case "failed":
+        return {
+          ...n,
+          failureCount: t.failureCount,
+          failureReason: t.error
+        };
+      case "pause":
+        return {
+          ...n,
+          isPaused: !0
+        };
+      case "continue":
+        return {
+          ...n,
+          isPaused: !1
+        };
+      case "pending":
+        return {
+          ...n,
+          context: t.context,
+          data: void 0,
+          failureCount: 0,
+          failureReason: null,
+          error: null,
+          isPaused: t.isPaused,
+          status: "pending",
+          variables: t.variables,
+          submittedAt: Date.now()
+        };
+      case "success":
+        return {
+          ...n,
+          data: t.data,
+          failureCount: 0,
+          failureReason: null,
+          error: null,
+          status: "success",
+          isPaused: !1
+        };
+      case "error":
+        return {
+          ...n,
+          data: void 0,
+          error: t.error,
+          failureCount: n.failureCount + 1,
+          failureReason: t.error,
+          isPaused: !1,
+          status: "error"
+        };
+    }
+  };
+  this.state = s(this.state), q.batch(() => {
+    c(this, y).forEach((n) => {
+      n.onMutationUpdate(t);
+    }), c(this, h).notify({
+      mutation: this,
+      type: "updated",
+      action: t
+    });
+  });
+}, k);
+function J() {
+  return {
+    context: void 0,
+    data: void 0,
+    error: null,
+    failureCount: 0,
+    failureReason: null,
+    isPaused: !1,
+    status: "idle",
+    variables: void 0,
+    submittedAt: 0
+  };
+}
+function lt(e, t, { checkForDefaultPrevented: s = !0 } = {}) {
+  return function(o) {
+    if (e == null || e(o), s === !1 || !o.defaultPrevented)
+      return t == null ? void 0 : t(o);
+  };
+}
+function ft(e, t) {
+  const s = r.createContext(t);
+  function n(i) {
+    const { children: u, ...a } = i, l = r.useMemo(() => a, Object.values(a));
+    return /* @__PURE__ */ P.jsx(s.Provider, { value: l, children: u });
+  }
+  function o(i) {
+    const u = r.useContext(s);
+    if (u) return u;
+    if (t !== void 0) return t;
+    throw new Error(`\`${i}\` must be used within \`${e}\``);
+  }
+  return n.displayName = e + "Provider", [n, o];
+}
+function ht(e, t = []) {
+  let s = [];
+  function n(i, u) {
+    const a = r.createContext(u), l = s.length;
+    s = [...s, u];
+    function d(p) {
+      const { scope: m, children: R, ...v } = p, j = (m == null ? void 0 : m[e][l]) || a, M = r.useMemo(() => v, Object.values(v));
+      return /* @__PURE__ */ P.jsx(j.Provider, { value: M, children: R });
+    }
+    function g(p, m) {
+      const R = (m == null ? void 0 : m[e][l]) || a, v = r.useContext(R);
+      if (v) return v;
+      if (u !== void 0) return u;
+      throw new Error(`\`${p}\` must be used within \`${i}\``);
+    }
+    return d.displayName = i + "Provider", [d, g];
+  }
+  const o = () => {
+    const i = s.map((u) => r.createContext(u));
+    return function(a) {
+      const l = (a == null ? void 0 : a[e]) || i;
+      return r.useMemo(
+        () => ({ [`__scope${e}`]: { ...a, [e]: l } }),
+        [a, l]
+      );
+    };
+  };
+  return o.scopeName = e, [n, K(o, ...t)];
+}
+function K(...e) {
+  const t = e[0];
+  if (e.length === 1) return t;
+  const s = () => {
+    const n = e.map((o) => ({
+      useScope: o(),
+      scopeName: o.scopeName
+    }));
+    return function(i) {
+      const u = n.reduce((a, { useScope: l, scopeName: d }) => {
+        const p = l(i)[`__scope${d}`];
+        return { ...a, ...p };
+      }, {});
+      return r.useMemo(() => ({ [`__scope${t.scopeName}`]: u }), [u]);
+    };
+  };
+  return s.scopeName = t.scopeName, s;
+}
+function T(e) {
+  const t = r.useRef(e);
+  return r.useEffect(() => {
+    t.current = e;
+  }), r.useMemo(() => (...s) => {
+    var n;
+    return (n = t.current) == null ? void 0 : n.call(t, ...s);
+  }, []);
+}
+function dt({
+  prop: e,
+  defaultProp: t,
+  onChange: s = () => {
+  }
+}) {
+  const [n, o] = Q({ defaultProp: t, onChange: s }), i = e !== void 0, u = i ? e : n, a = T(s), l = r.useCallback(
+    (d) => {
+      if (i) {
+        const p = typeof d == "function" ? d(e) : d;
+        p !== e && a(p);
+      } else
+        o(d);
+    },
+    [i, e, o, a]
+  );
+  return [u, l];
+}
+function Q({
+  defaultProp: e,
+  onChange: t
+}) {
+  const s = r.useState(e), [n] = s, o = r.useRef(n), i = T(t);
+  return r.useEffect(() => {
+    o.current !== n && (i(n), o.current = n);
+  }, [n, o, i]), s;
+}
+var X = globalThis != null && globalThis.document ? r.useLayoutEffect : () => {
+};
+function Y(e, t) {
+  typeof e == "function" ? e(t) : e != null && (e.current = t);
+}
+function B(...e) {
+  return (t) => e.forEach((s) => Y(s, t));
+}
+function pt(...e) {
+  return r.useCallback(B(...e), e);
+}
+var U = r.forwardRef((e, t) => {
+  const { children: s, ...n } = e, o = r.Children.toArray(s), i = o.find(tt);
+  if (i) {
+    const u = i.props.children, a = o.map((l) => l === i ? r.Children.count(u) > 1 ? r.Children.only(null) : r.isValidElement(u) ? u.props.children : null : l);
+    return /* @__PURE__ */ P.jsx(D, { ...n, ref: t, children: r.isValidElement(u) ? r.cloneElement(u, void 0, a) : null });
+  }
+  return /* @__PURE__ */ P.jsx(D, { ...n, ref: t, children: s });
+});
+U.displayName = "Slot";
+var D = r.forwardRef((e, t) => {
+  const { children: s, ...n } = e;
+  if (r.isValidElement(s)) {
+    const o = st(s);
+    return r.cloneElement(s, {
+      ...et(n, s.props),
+      // @ts-ignore
+      ref: t ? B(t, o) : o
+    });
+  }
+  return r.Children.count(s) > 1 ? r.Children.only(null) : null;
+});
+D.displayName = "SlotClone";
+var H = ({ children: e }) => /* @__PURE__ */ P.jsx(P.Fragment, { children: e });
+function tt(e) {
+  return r.isValidElement(e) && e.type === H;
+}
+function et(e, t) {
+  const s = { ...t };
+  for (const n in t) {
+    const o = e[n], i = t[n];
+    /^on[A-Z]/.test(n) ? o && i ? s[n] = (...a) => {
+      i(...a), o(...a);
+    } : o && (s[n] = o) : n === "style" ? s[n] = { ...o, ...i } : n === "className" && (s[n] = [o, i].filter(Boolean).join(" "));
+  }
+  return { ...e, ...s };
+}
+function st(e) {
+  var n, o;
+  let t = (n = Object.getOwnPropertyDescriptor(e.props, "ref")) == null ? void 0 : n.get, s = t && "isReactWarning" in t && t.isReactWarning;
+  return s ? e.ref : (t = (o = Object.getOwnPropertyDescriptor(e, "ref")) == null ? void 0 : o.get, s = t && "isReactWarning" in t && t.isReactWarning, s ? e.props.ref : e.props.ref || e.ref);
+}
+var nt = [
+  "a",
+  "button",
+  "div",
+  "form",
+  "h2",
+  "h3",
+  "img",
+  "input",
+  "label",
+  "li",
+  "nav",
+  "ol",
+  "p",
+  "span",
+  "svg",
+  "ul"
+], mt = nt.reduce((e, t) => {
+  const s = r.forwardRef((n, o) => {
+    const { asChild: i, ...u } = n, a = i ? U : t;
+    return typeof window < "u" && (window[Symbol.for("radix-ui")] = !0), /* @__PURE__ */ P.jsx(a, { ...u, ref: o });
+  });
+  return s.displayName = `Primitive.${t}`, { ...e, [t]: s };
+}, {});
+function yt(e, t) {
+  e && z.flushSync(() => e.dispatchEvent(t));
+}
+var ot = r.useId || (() => {
+}), rt = 0;
+function xt(e) {
+  const [t, s] = r.useState(ot());
+  return X(() => {
+    s((n) => n ?? String(rt++));
+  }, [e]), t ? `radix-${t}` : "";
+}
+export {
+  ct as M,
+  mt as P,
+  U as S,
+  dt as a,
+  T as b,
+  ht as c,
+  lt as d,
+  xt as e,
+  ft as f,
+  X as g,
+  J as h,
+  yt as i,
+  pt as u
+};

package/lib/{index-DNx3xWa2.js → index-PyGcnQFX.js}

@@ -3440,21 +3440,22 @@ export {
   fa as O,
   De as R,
   zn as a,
-  Ve as b,
-  sa as c,
-  Jn as d,
-  yt as e,
-  ca as f,
-  Ne as g,
-  la as h,
+  ra as b,
+  Ve as c,
+  sa as d,
+  Jn as e,
+  yt as f,
+  ca as g,
+  Ne as h,
   M as i,
   oa as j,
-  ia as k,
-  pa as l,
+  la as k,
+  ia as l,
   fr as m,
-  It as n,
-  ha as o,
-  ua as p,
+  pa as n,
+  It as o,
+  ha as p,
+  ua as q,
   Et as s,
   Bt as u,
   te as w

package/lib/loglevel-CA34MiFn.js

@@ -0,0 +1,152 @@
+import { c as N, g as _ } from "./_commonjsHelpers-BkfeUUK-.js";
+var I = { exports: {} };
+(function(w) {
+  (function(g, i) {
+    w.exports ? w.exports = i() : g.log = i();
+  })(N, function() {
+    var g = function() {
+    }, i = "undefined", C = typeof window !== i && typeof window.navigator !== i && /Trident\/|MSIE /.test(window.navigator.userAgent), p = [
+      "trace",
+      "debug",
+      "info",
+      "warn",
+      "error"
+    ], a = {}, l = null;
+    function h(o, t) {
+      var e = o[t];
+      if (typeof e.bind == "function")
+        return e.bind(o);
+      try {
+        return Function.prototype.bind.call(e, o);
+      } catch {
+        return function() {
+          return Function.prototype.apply.apply(e, [o, arguments]);
+        };
+      }
+    }
+    function T() {
+      console.log && (console.log.apply ? console.log.apply(console, arguments) : Function.prototype.apply.apply(console.log, [console, arguments])), console.trace && console.trace();
+    }
+    function x(o) {
+      return o === "debug" && (o = "log"), typeof console === i ? !1 : o === "trace" && C ? T : console[o] !== void 0 ? h(console, o) : console.log !== void 0 ? h(console, "log") : g;
+    }
+    function c() {
+      for (var o = this.getLevel(), t = 0; t < p.length; t++) {
+        var e = p[t];
+        this[e] = t < o ? g : this.methodFactory(e, o, this.name);
+      }
+      if (this.log = this.debug, typeof console === i && o < this.levels.SILENT)
+        return "No console available for logging";
+    }
+    function F(o) {
+      return function() {
+        typeof console !== i && (c.call(this), this[o].apply(this, arguments));
+      };
+    }
+    function R(o, t, e) {
+      return x(o) || F.apply(this, arguments);
+    }
+    function L(o, t) {
+      var e = this, v, y, f, s = "loglevel";
+      typeof o == "string" ? s += ":" + o : typeof o == "symbol" && (s = void 0);
+      function S(n) {
+        var r = (p[n] || "silent").toUpperCase();
+        if (!(typeof window === i || !s)) {
+          try {
+            window.localStorage[s] = r;
+            return;
+          } catch {
+          }
+          try {
+            window.document.cookie = encodeURIComponent(s) + "=" + r + ";";
+          } catch {
+          }
+        }
+      }
+      function b() {
+        var n;
+        if (!(typeof window === i || !s)) {
+          try {
+            n = window.localStorage[s];
+          } catch {
+          }
+          if (typeof n === i)
+            try {
+              var r = window.document.cookie, d = encodeURIComponent(s), m = r.indexOf(d + "=");
+              m !== -1 && (n = /^([^;]+)/.exec(
+                r.slice(m + d.length + 1)
+              )[1]);
+            } catch {
+            }
+          return e.levels[n] === void 0 && (n = void 0), n;
+        }
+      }
+      function U() {
+        if (!(typeof window === i || !s)) {
+          try {
+            window.localStorage.removeItem(s);
+          } catch {
+          }
+          try {
+            window.document.cookie = encodeURIComponent(s) + "=; expires=Thu, 01 Jan 1970 00:00:00 UTC";
+          } catch {
+          }
+        }
+      }
+      function u(n) {
+        var r = n;
+        if (typeof r == "string" && e.levels[r.toUpperCase()] !== void 0 && (r = e.levels[r.toUpperCase()]), typeof r == "number" && r >= 0 && r <= e.levels.SILENT)
+          return r;
+        throw new TypeError("log.setLevel() called with invalid level: " + n);
+      }
+      e.name = o, e.levels = {
+        TRACE: 0,
+        DEBUG: 1,
+        INFO: 2,
+        WARN: 3,
+        ERROR: 4,
+        SILENT: 5
+      }, e.methodFactory = t || R, e.getLevel = function() {
+        return f ?? y ?? v;
+      }, e.setLevel = function(n, r) {
+        return f = u(n), r !== !1 && S(f), c.call(e);
+      }, e.setDefaultLevel = function(n) {
+        y = u(n), b() || e.setLevel(n, !1);
+      }, e.resetLevel = function() {
+        f = null, U(), c.call(e);
+      }, e.enableAll = function(n) {
+        e.setLevel(e.levels.TRACE, n);
+      }, e.disableAll = function(n) {
+        e.setLevel(e.levels.SILENT, n);
+      }, e.rebuild = function() {
+        if (l !== e && (v = u(l.getLevel())), c.call(e), l === e)
+          for (var n in a)
+            a[n].rebuild();
+      }, v = u(
+        l ? l.getLevel() : "WARN"
+      );
+      var E = b();
+      E != null && (f = u(E)), c.call(e);
+    }
+    l = new L(), l.getLogger = function(t) {
+      if (typeof t != "symbol" && typeof t != "string" || t === "")
+        throw new TypeError("You must supply a name when creating a logger.");
+      var e = a[t];
+      return e || (e = a[t] = new L(
+        t,
+        l.methodFactory
+      )), e;
+    };
+    var A = typeof window !== i ? window.log : void 0;
+    return l.noConflict = function() {
+      return typeof window !== i && window.log === l && (window.log = A), l;
+    }, l.getLoggers = function() {
+      return a;
+    }, l.default = l, l;
+  });
+})(I);
+var D = I.exports;
+const P = /* @__PURE__ */ _(D);
+export {
+  P as l
+};

package/lib/prism-csharp.min-Yizuc34Y.js

@@ -0,0 +1,34 @@
+(function(s) {
+  function n(a, o) {
+    return a.replace(/<<(\d+)>>/g, function(f, H) {
+      return "(?:" + o[+H] + ")";
+    });
+  }
+  function e(a, o, f) {
+    return RegExp(n(a, o), "");
+  }
+  function d(a, o) {
+    for (var f = 0; f < o; f++) a = a.replace(/<<self>>/g, function() {
+      return "(?:" + a + ")";
+    });
+    return a.replace(/<<self>>/g, "[^\\s\\S]");
+  }
+  var w = "bool byte char decimal double dynamic float int long object sbyte short string uint ulong ushort var void", p = "class enum interface record struct", v = "add alias and ascending async await by descending from(?=\\s*(?:\\w|$)) get global group into init(?=\\s*;) join let nameof not notnull on or orderby partial remove select set unmanaged value when where with(?=\\s*{)", m = "abstract as base break case catch checked const continue default delegate do else event explicit extern finally fixed for foreach goto if implicit in internal is lock namespace new null operator out override params private protected public readonly ref return sealed sizeof stackalloc static switch this throw try typeof unchecked unsafe using virtual volatile while yield";
+  function c(a) {
+    return "\\b(?:" + a.trim().replace(/ /g, "|") + ")\\b";
+  }
+  var x = c(p), u = RegExp(c(w + " " + p + " " + v + " " + m)), U = c(p + " " + v + " " + m), Z = c(w + " " + p + " " + m), g = d("<(?:[^<>;=+\\-*/%&|^]|<<self>>)*>", 2), b = d("\\((?:[^()]|<<self>>)*\\)", 2), r = "@?\\b[A-Za-z_]\\w*\\b", h = n("<<0>>(?:\\s*<<1>>)?", [r, g]), i = n("(?!<<0>>)<<1>>(?:\\s*\\.\\s*<<1>>)*", [U, h]), k = "\\[\\s*(?:,\\s*)*\\]", q = n("<<0>>(?:\\s*(?:\\?\\s*)?<<1>>)*(?:\\s*\\?)?", [i, k]), C = n("[^,()<>[\\];=+\\-*/%&|^]|<<0>>|<<1>>|<<2>>", [g, b, k]), D = n("\\(<<0>>+(?:,<<0>>+)+\\)", [C]), l = n("(?:<<0>>|<<1>>)(?:\\s*(?:\\?\\s*)?<<2>>)*(?:\\s*\\?)?", [D, i, k]), t = { keyword: u, punctuation: /[<>()?,.:[\]]/ }, $ = `'(?:[^\r
+'\\\\]|\\\\.|\\\\[Uux][\\da-fA-F]{1,8})'`, _ = `"(?:\\\\.|[^\\\\"\r
+])*"`;
+  s.languages.csharp = s.languages.extend("clike", { string: [{ pattern: e("(^|[^$\\\\])<<0>>", ['@"(?:""|\\\\[^]|[^\\\\"])*"(?!")']), lookbehind: !0, greedy: !0 }, { pattern: e("(^|[^@$\\\\])<<0>>", [_]), lookbehind: !0, greedy: !0 }], "class-name": [{ pattern: e("(\\busing\\s+static\\s+)<<0>>(?=\\s*;)", [i]), lookbehind: !0, inside: t }, { pattern: e("(\\busing\\s+<<0>>\\s*=\\s*)<<1>>(?=\\s*;)", [r, l]), lookbehind: !0, inside: t }, { pattern: e("(\\busing\\s+)<<0>>(?=\\s*=)", [r]), lookbehind: !0 }, { pattern: e("(\\b<<0>>\\s+)<<1>>", [x, h]), lookbehind: !0, inside: t }, { pattern: e("(\\bcatch\\s*\\(\\s*)<<0>>", [i]), lookbehind: !0, inside: t }, { pattern: e("(\\bwhere\\s+)<<0>>", [r]), lookbehind: !0 }, { pattern: e("(\\b(?:is(?:\\s+not)?|as)\\s+)<<0>>", [q]), lookbehind: !0, inside: t }, { pattern: e("\\b<<0>>(?=\\s+(?!<<1>>|with\\s*\\{)<<2>>(?:\\s*[=,;:{)\\]]|\\s+(?:in|when)\\b))", [l, Z, r]), inside: t }], keyword: u, number: /(?:\b0(?:x[\da-f_]*[\da-f]|b[01_]*[01])|(?:\B\.\d+(?:_+\d+)*|\b\d+(?:_+\d+)*(?:\.\d+(?:_+\d+)*)?)(?:e[-+]?\d+(?:_+\d+)*)?)(?:[dflmu]|lu|ul)?\b/i, operator: />>=?|<<=?|[-=]>|([-+&|])\1|~|\?\?=?|[-+*/%&|^!=<>]=?/, punctuation: /\?\.?|::|[{}[\];(),.:]/ }), s.languages.insertBefore("csharp", "number", { range: { pattern: /\.\./, alias: "operator" } }), s.languages.insertBefore("csharp", "punctuation", { "named-parameter": { pattern: e("([(,]\\s*)<<0>>(?=\\s*:)", [r]), lookbehind: !0, alias: "punctuation" } }), s.languages.insertBefore("csharp", "class-name", { namespace: { pattern: e("(\\b(?:namespace|using)\\s+)<<0>>(?:\\s*\\.\\s*<<0>>)*(?=\\s*[;{])", [r]), lookbehind: !0, inside: { punctuation: /\./ } }, "type-expression": { pattern: e("(\\b(?:default|sizeof|typeof)\\s*\\(\\s*(?!\\s))(?:[^()\\s]|\\s(?!\\s)|<<0>>)*(?=\\s*\\))", [b]), lookbehind: !0, alias: "class-name", inside: t }, "return-type": { pattern: e("<<0>>(?=\\s+(?:<<1>>\\s*(?:=>|[({]|\\.\\s*this\\s*\\[)|this\\s*\\[))", [l, i]), inside: t, alias: "class-name" }, "constructor-invocation": { pattern: e("(\\bnew\\s+)<<0>>(?=\\s*[[({])", [l]), lookbehind: !0, inside: t, alias: "class-name" }, "generic-method": { pattern: e("<<0>>\\s*<<1>>(?=\\s*\\()", [r, g]), inside: { function: e("^<<0>>", [r]), generic: { pattern: RegExp(g), alias: "class-name", inside: t } } }, "type-list": { pattern: e("\\b((?:<<0>>\\s+<<1>>|record\\s+<<1>>\\s*<<5>>|where\\s+<<2>>)\\s*:\\s*)(?:<<3>>|<<4>>|<<1>>\\s*<<5>>|<<6>>)(?:\\s*,\\s*(?:<<3>>|<<4>>|<<6>>))*(?=\\s*(?:where|[{;]|=>|$))", [x, h, r, l, u.source, b, "\\bnew\\s*\\(\\s*\\)"]), lookbehind: !0, inside: { "record-arguments": { pattern: e("(^(?!new\\s*\\()<<0>>\\s*)<<1>>", [h, b]), lookbehind: !0, greedy: !0, inside: s.languages.csharp }, keyword: u, "class-name": { pattern: RegExp(l), greedy: !0, inside: t }, punctuation: /[,()]/ } }, preprocessor: { pattern: /(^[\t ]*)#.*/m, lookbehind: !0, alias: "property", inside: { directive: { pattern: /(#)\b(?:define|elif|else|endif|endregion|error|if|line|nullable|pragma|region|undef|warning)\b/, lookbehind: !0, alias: "keyword" } } } });
+  var B = _ + "|" + $, E = n(`/(?![*/])|//[^\r
+]*[\r
+]|/\\*(?:[^*]|\\*(?!/))*\\*/|<<0>>`, [B]), R = d(n(`[^"'/()]|<<0>>|\\(<<self>>*\\)`, [E]), 2), z = "\\b(?:assembly|event|field|method|module|param|property|return|type)\\b", G = n("<<0>>(?:\\s*\\(<<1>>*\\))?", [i, R]);
+  s.languages.insertBefore("csharp", "class-name", { attribute: { pattern: e("((?:^|[^\\s\\w>)?])\\s*\\[\\s*)(?:<<0>>\\s*:\\s*)?<<1>>(?:\\s*,\\s*<<1>>)*(?=\\s*\\])", [z, G]), lookbehind: !0, greedy: !0, inside: { target: { pattern: e("^<<0>>(?=\\s*:)", [z]), alias: "keyword" }, "attribute-arguments": { pattern: e("\\(<<0>>*\\)", [R]), inside: s.languages.csharp }, "class-name": { pattern: RegExp(i), inside: { punctuation: /\./ } }, punctuation: /[:,]/ } } });
+  var y = `:[^}\r
+]+`, S = d(n(`[^"'/()]|<<0>>|\\(<<self>>*\\)`, [E]), 2), j = n("\\{(?!\\{)(?:(?![}:])<<0>>)*<<1>>?\\}", [S, y]), A = d(n(`[^"'/()]|/(?!\\*)|/\\*(?:[^*]|\\*(?!/))*\\*/|<<0>>|\\(<<self>>*\\)`, [B]), 2), F = n("\\{(?!\\{)(?:(?![}:])<<0>>)*<<1>>?\\}", [A, y]);
+  function P(a, o) {
+    return { interpolation: { pattern: e("((?:^|[^{])(?:\\{\\{)*)<<0>>", [a]), lookbehind: !0, inside: { "format-string": { pattern: e("(^\\{(?:(?![}:])<<0>>)*)<<1>>(?=\\}$)", [o, y]), lookbehind: !0, inside: { punctuation: /^:/ } }, punctuation: /^\{|\}$/, expression: { pattern: /[\s\S]+/, alias: "language-csharp", inside: s.languages.csharp } } }, string: /[\s\S]+/ };
+  }
+  s.languages.insertBefore("csharp", "string", { "interpolation-string": [{ pattern: e('(^|[^\\\\])(?:\\$@|@\\$)"(?:""|\\\\[^]|\\{\\{|<<0>>|[^\\\\{"])*"', [j]), lookbehind: !0, greedy: !0, inside: P(j, S) }, { pattern: e('(^|[^@\\\\])\\$"(?:\\\\.|\\{\\{|<<0>>|[^\\\\"{])*"', [F]), lookbehind: !0, greedy: !0, inside: P(F, A) }], char: { pattern: RegExp($), greedy: !0 } }), s.languages.dotnet = s.languages.cs = s.languages.csharp;
+})(Prism);

package/lib/prism-objectivec.min-BXSWqpJJ.js

@@ -0,0 +1 @@
+Prism.languages.objectivec = Prism.languages.extend("c", { string: { pattern: /@?"(?:\\(?:\r\n|[\s\S])|[^"\\\r\n])*"/, greedy: !0 }, keyword: /\b(?:asm|auto|break|case|char|const|continue|default|do|double|else|enum|extern|float|for|goto|if|in|inline|int|long|register|return|self|short|signed|sizeof|static|struct|super|switch|typedef|typeof|union|unsigned|void|volatile|while)\b|(?:@interface|@end|@implementation|@protocol|@class|@public|@protected|@private|@property|@try|@catch|@finally|@throw|@synthesize|@dynamic|@selector)\b/, operator: /-[->]?|\+\+?|!=?|<<?=?|>>?=?|==?|&&?|\|\|?|[~^%?*\/@]/ }), delete Prism.languages.objectivec["class-name"], Prism.languages.objc = Prism.languages.objectivec;