@pod-os/elements 0.36.0 → 0.37.0-rc.0b98c3c.0

package/dist/esm/{index-DFqG64hG.js → index-BF-69-JC.js}

@@ -11599,346 +11599,6 @@ var require_browser_ponyfill = __commonJS({
   }
 });
 
-// ../node_modules/short-unique-id/dist/short-unique-id.js
-var require_short_unique_id = __commonJS({
-  "../node_modules/short-unique-id/dist/short-unique-id.js"(exports, module3) {
-    var ShortUniqueId2 = (() => {
-      var __defProp = Object.defineProperty;
-      var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-      var __getOwnPropNames = Object.getOwnPropertyNames;
-      var __getOwnPropSymbols = Object.getOwnPropertySymbols;
-      var __hasOwnProp = Object.prototype.hasOwnProperty;
-      var __propIsEnum = Object.prototype.propertyIsEnumerable;
-      var __defNormalProp = (obj, key3, value7) => key3 in obj ? __defProp(obj, key3, { enumerable: true, configurable: true, writable: true, value: value7 }) : obj[key3] = value7;
-      var __spreadValues = (a, b) => {
-        for (var prop in b || (b = {}))
-          if (__hasOwnProp.call(b, prop))
-            __defNormalProp(a, prop, b[prop]);
-        if (__getOwnPropSymbols)
-          for (var prop of __getOwnPropSymbols(b)) {
-            if (__propIsEnum.call(b, prop))
-              __defNormalProp(a, prop, b[prop]);
-          }
-        return a;
-      };
-      var __export2 = (target6, all) => {
-        for (var name9 in all)
-          __defProp(target6, name9, { get: all[name9], enumerable: true });
-      };
-      var __copyProps = (to2, from2, except, desc) => {
-        if (from2 && typeof from2 === "object" || typeof from2 === "function") {
-          for (let key3 of __getOwnPropNames(from2))
-            if (!__hasOwnProp.call(to2, key3) && key3 !== except)
-              __defProp(to2, key3, { get: () => from2[key3], enumerable: !(desc = __getOwnPropDesc(from2, key3)) || desc.enumerable });
-        }
-        return to2;
-      };
-      var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-      var __publicField = (obj, key3, value7) => {
-        __defNormalProp(obj, typeof key3 !== "symbol" ? key3 + "" : key3, value7);
-        return value7;
-      };
-      var src_exports = {};
-      __export2(src_exports, {
-        DEFAULT_OPTIONS: () => DEFAULT_OPTIONS,
-        DEFAULT_UUID_LENGTH: () => DEFAULT_UUID_LENGTH,
-        default: () => ShortUniqueId3
-      });
-      var version6 = "5.2.0";
-      var DEFAULT_UUID_LENGTH = 6;
-      var DEFAULT_OPTIONS = {
-        dictionary: "alphanum",
-        shuffle: true,
-        debug: false,
-        length: DEFAULT_UUID_LENGTH,
-        counter: 0
-      };
-      var _ShortUniqueId = class _ShortUniqueId {
-        constructor(argOptions = {}) {
-          __publicField(this, "counter");
-          __publicField(this, "debug");
-          __publicField(this, "dict");
-          __publicField(this, "version");
-          __publicField(this, "dictIndex", 0);
-          __publicField(this, "dictRange", []);
-          __publicField(this, "lowerBound", 0);
-          __publicField(this, "upperBound", 0);
-          __publicField(this, "dictLength", 0);
-          __publicField(this, "uuidLength");
-          __publicField(this, "_digit_first_ascii", 48);
-          __publicField(this, "_digit_last_ascii", 58);
-          __publicField(this, "_alpha_lower_first_ascii", 97);
-          __publicField(this, "_alpha_lower_last_ascii", 123);
-          __publicField(this, "_hex_last_ascii", 103);
-          __publicField(this, "_alpha_upper_first_ascii", 65);
-          __publicField(this, "_alpha_upper_last_ascii", 91);
-          __publicField(this, "_number_dict_ranges", {
-            digits: [this._digit_first_ascii, this._digit_last_ascii]
-          });
-          __publicField(this, "_alpha_dict_ranges", {
-            lowerCase: [this._alpha_lower_first_ascii, this._alpha_lower_last_ascii],
-            upperCase: [this._alpha_upper_first_ascii, this._alpha_upper_last_ascii]
-          });
-          __publicField(this, "_alpha_lower_dict_ranges", {
-            lowerCase: [this._alpha_lower_first_ascii, this._alpha_lower_last_ascii]
-          });
-          __publicField(this, "_alpha_upper_dict_ranges", {
-            upperCase: [this._alpha_upper_first_ascii, this._alpha_upper_last_ascii]
-          });
-          __publicField(this, "_alphanum_dict_ranges", {
-            digits: [this._digit_first_ascii, this._digit_last_ascii],
-            lowerCase: [this._alpha_lower_first_ascii, this._alpha_lower_last_ascii],
-            upperCase: [this._alpha_upper_first_ascii, this._alpha_upper_last_ascii]
-          });
-          __publicField(this, "_alphanum_lower_dict_ranges", {
-            digits: [this._digit_first_ascii, this._digit_last_ascii],
-            lowerCase: [this._alpha_lower_first_ascii, this._alpha_lower_last_ascii]
-          });
-          __publicField(this, "_alphanum_upper_dict_ranges", {
-            digits: [this._digit_first_ascii, this._digit_last_ascii],
-            upperCase: [this._alpha_upper_first_ascii, this._alpha_upper_last_ascii]
-          });
-          __publicField(this, "_hex_dict_ranges", {
-            decDigits: [this._digit_first_ascii, this._digit_last_ascii],
-            alphaDigits: [this._alpha_lower_first_ascii, this._hex_last_ascii]
-          });
-          __publicField(this, "_dict_ranges", {
-            _number_dict_ranges: this._number_dict_ranges,
-            _alpha_dict_ranges: this._alpha_dict_ranges,
-            _alpha_lower_dict_ranges: this._alpha_lower_dict_ranges,
-            _alpha_upper_dict_ranges: this._alpha_upper_dict_ranges,
-            _alphanum_dict_ranges: this._alphanum_dict_ranges,
-            _alphanum_lower_dict_ranges: this._alphanum_lower_dict_ranges,
-            _alphanum_upper_dict_ranges: this._alphanum_upper_dict_ranges,
-            _hex_dict_ranges: this._hex_dict_ranges
-          });
-          __publicField(this, "log", (...args) => {
-            const finalArgs = [...args];
-            finalArgs[0] = `[short-unique-id] ${args[0]}`;
-            if (this.debug === true) {
-              if (typeof console !== "undefined" && console !== null) {
-                return console.log(...finalArgs);
-              }
-            }
-          });
-          __publicField(this, "_normalizeDictionary", (dictionary2, shuffle2) => {
-            let finalDict;
-            if (dictionary2 && Array.isArray(dictionary2) && dictionary2.length > 1) {
-              finalDict = dictionary2;
-            } else {
-              finalDict = [];
-              let i;
-              this.dictIndex = i = 0;
-              const rangesName = `_${dictionary2}_dict_ranges`;
-              const ranges = this._dict_ranges[rangesName];
-              Object.keys(ranges).forEach((rangeType) => {
-                const rangeTypeKey = rangeType;
-                this.dictRange = ranges[rangeTypeKey];
-                this.lowerBound = this.dictRange[0];
-                this.upperBound = this.dictRange[1];
-                for (this.dictIndex = i = this.lowerBound; this.lowerBound <= this.upperBound ? i < this.upperBound : i > this.upperBound; this.dictIndex = this.lowerBound <= this.upperBound ? i += 1 : i -= 1) {
-                  finalDict.push(String.fromCharCode(this.dictIndex));
-                }
-              });
-            }
-            if (shuffle2) {
-              const PROBABILITY = 0.5;
-              finalDict = finalDict.sort(() => Math.random() - PROBABILITY);
-            }
-            return finalDict;
-          });
-          __publicField(this, "setDictionary", (dictionary2, shuffle2) => {
-            this.dict = this._normalizeDictionary(dictionary2, shuffle2);
-            this.dictLength = this.dict.length;
-            this.setCounter(0);
-          });
-          __publicField(this, "seq", () => {
-            return this.sequentialUUID();
-          });
-          __publicField(this, "sequentialUUID", () => {
-            let counterDiv;
-            let counterRem;
-            let id4 = "";
-            counterDiv = this.counter;
-            do {
-              counterRem = counterDiv % this.dictLength;
-              counterDiv = Math.trunc(counterDiv / this.dictLength);
-              id4 += this.dict[counterRem];
-            } while (counterDiv !== 0);
-            this.counter += 1;
-            return id4;
-          });
-          __publicField(this, "rnd", (uuidLength = this.uuidLength || DEFAULT_UUID_LENGTH) => {
-            return this.randomUUID(uuidLength);
-          });
-          __publicField(this, "randomUUID", (uuidLength = this.uuidLength || DEFAULT_UUID_LENGTH) => {
-            let id4;
-            let randomPartIdx;
-            let j;
-            if (uuidLength === null || typeof uuidLength === "undefined" || uuidLength < 1) {
-              throw new Error("Invalid UUID Length Provided");
-            }
-            id4 = "";
-            for (j = 0; j < uuidLength; j += 1) {
-              randomPartIdx = parseInt(
-                (Math.random() * this.dictLength).toFixed(0),
-                10
-              ) % this.dictLength;
-              id4 += this.dict[randomPartIdx];
-            }
-            return id4;
-          });
-          __publicField(this, "fmt", (format4, date6) => {
-            return this.formattedUUID(format4, date6);
-          });
-          __publicField(this, "formattedUUID", (format4, date6) => {
-            const fnMap = {
-              "$r": this.randomUUID,
-              "$s": this.sequentialUUID,
-              "$t": this.stamp
-            };
-            const result6 = format4.replace(
-              /\$[rs]\d{0,}|\$t0|\$t[1-9]\d{1,}/g,
-              (m) => {
-                const fn2 = m.slice(0, 2);
-                const len = parseInt(m.slice(2), 10);
-                if (fn2 === "$s") {
-                  return fnMap[fn2]().padStart(len, "0");
-                }
-                if (fn2 === "$t" && date6) {
-                  return fnMap[fn2](len, date6);
-                }
-                return fnMap[fn2](len);
-              }
-            );
-            return result6;
-          });
-          __publicField(this, "availableUUIDs", (uuidLength = this.uuidLength) => {
-            return parseFloat(
-              Math.pow([...new Set(this.dict)].length, uuidLength).toFixed(0)
-            );
-          });
-          __publicField(this, "approxMaxBeforeCollision", (rounds = this.availableUUIDs(this.uuidLength)) => {
-            return parseFloat(
-              Math.sqrt(Math.PI / 2 * rounds).toFixed(20)
-            );
-          });
-          __publicField(this, "collisionProbability", (rounds = this.availableUUIDs(this.uuidLength), uuidLength = this.uuidLength) => {
-            return parseFloat(
-              (this.approxMaxBeforeCollision(rounds) / this.availableUUIDs(uuidLength)).toFixed(20)
-            );
-          });
-          __publicField(this, "uniqueness", (rounds = this.availableUUIDs(this.uuidLength)) => {
-            const score2 = parseFloat(
-              (1 - this.approxMaxBeforeCollision(rounds) / rounds).toFixed(20)
-            );
-            return score2 > 1 ? 1 : score2 < 0 ? 0 : score2;
-          });
-          __publicField(this, "getVersion", () => {
-            return this.version;
-          });
-          __publicField(this, "stamp", (finalLength, date6) => {
-            const hexStamp = Math.floor(+(date6 || /* @__PURE__ */ new Date()) / 1e3).toString(16);
-            if (typeof finalLength === "number" && finalLength === 0) {
-              return hexStamp;
-            }
-            if (typeof finalLength !== "number" || finalLength < 10) {
-              throw new Error(
-                [
-                  "Param finalLength must be a number greater than or equal to 10,",
-                  "or 0 if you want the raw hexadecimal timestamp"
-                ].join("\n")
-              );
-            }
-            const idLength = finalLength - 9;
-            const rndIdx = Math.round(Math.random() * (idLength > 15 ? 15 : idLength));
-            const id4 = this.randomUUID(idLength);
-            return `${id4.substring(0, rndIdx)}${hexStamp}${id4.substring(rndIdx)}${rndIdx.toString(16)}`;
-          });
-          __publicField(this, "parseStamp", (suid, format4) => {
-            if (format4 && !/t0|t[1-9]\d{1,}/.test(format4)) {
-              throw new Error("Cannot extract date from a formated UUID with no timestamp in the format");
-            }
-            const stamp = format4 ? format4.replace(
-              /\$[rs]\d{0,}|\$t0|\$t[1-9]\d{1,}/g,
-              (m) => {
-                const fnMap = {
-                  "$r": (len2) => [...Array(len2)].map(() => "r").join(""),
-                  "$s": (len2) => [...Array(len2)].map(() => "s").join(""),
-                  "$t": (len2) => [...Array(len2)].map(() => "t").join("")
-                };
-                const fn2 = m.slice(0, 2);
-                const len = parseInt(m.slice(2), 10);
-                return fnMap[fn2](len);
-              }
-            ).replace(
-              /^(.*?)(t{8,})(.*)$/g,
-              (_m, p1, p2) => {
-                return suid.substring(p1.length, p1.length + p2.length);
-              }
-            ) : suid;
-            if (stamp.length === 8) {
-              return new Date(parseInt(stamp, 16) * 1e3);
-            }
-            if (stamp.length < 10) {
-              throw new Error("Stamp length invalid");
-            }
-            const rndIdx = parseInt(stamp.substring(stamp.length - 1), 16);
-            return new Date(parseInt(stamp.substring(rndIdx, rndIdx + 8), 16) * 1e3);
-          });
-          __publicField(this, "setCounter", (counter2) => {
-            this.counter = counter2;
-          });
-          __publicField(this, "validate", (uid4, dictionary2) => {
-            const finalDictionary = dictionary2 ? this._normalizeDictionary(dictionary2) : this.dict;
-            return uid4.split("").every((c) => finalDictionary.includes(c));
-          });
-          const options = __spreadValues(__spreadValues({}, DEFAULT_OPTIONS), argOptions);
-          this.counter = 0;
-          this.debug = false;
-          this.dict = [];
-          this.version = version6;
-          const {
-            dictionary,
-            shuffle,
-            length: length3,
-            counter
-          } = options;
-          this.uuidLength = length3;
-          this.setDictionary(dictionary, shuffle);
-          this.setCounter(counter);
-          this.debug = options.debug;
-          this.log(this.dict);
-          this.log(
-            `Generator instantiated with Dictionary Size ${this.dictLength} and counter set to ${this.counter}`
-          );
-          this.log = this.log.bind(this);
-          this.setDictionary = this.setDictionary.bind(this);
-          this.setCounter = this.setCounter.bind(this);
-          this.seq = this.seq.bind(this);
-          this.sequentialUUID = this.sequentialUUID.bind(this);
-          this.rnd = this.rnd.bind(this);
-          this.randomUUID = this.randomUUID.bind(this);
-          this.fmt = this.fmt.bind(this);
-          this.formattedUUID = this.formattedUUID.bind(this);
-          this.availableUUIDs = this.availableUUIDs.bind(this);
-          this.approxMaxBeforeCollision = this.approxMaxBeforeCollision.bind(this);
-          this.collisionProbability = this.collisionProbability.bind(this);
-          this.uniqueness = this.uniqueness.bind(this);
-          this.getVersion = this.getVersion.bind(this);
-          this.stamp = this.stamp.bind(this);
-          this.parseStamp = this.parseStamp.bind(this);
-          return this;
-        }
-      };
-      __publicField(_ShortUniqueId, "default", _ShortUniqueId);
-      var ShortUniqueId3 = _ShortUniqueId;
-      return __toCommonJS(src_exports);
-    })();
-    "undefined" != typeof module3 && (module3.exports = ShortUniqueId2.default), "undefined" != typeof window && (ShortUniqueId2 = ShortUniqueId2.default);
-  }
-});
-
 // ../node_modules/lunr/lunr.js
 var require_lunr = __commonJS({
   "../node_modules/lunr/lunr.js"(exports, module3) {
@@ -13670,6 +13330,346 @@ var require_lunr = __commonJS({
   }
 });
 
+// ../node_modules/short-unique-id/dist/short-unique-id.js
+var require_short_unique_id = __commonJS({
+  "../node_modules/short-unique-id/dist/short-unique-id.js"(exports, module3) {
+    var ShortUniqueId2 = (() => {
+      var __defProp = Object.defineProperty;
+      var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+      var __getOwnPropNames = Object.getOwnPropertyNames;
+      var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+      var __hasOwnProp = Object.prototype.hasOwnProperty;
+      var __propIsEnum = Object.prototype.propertyIsEnumerable;
+      var __defNormalProp = (obj, key3, value7) => key3 in obj ? __defProp(obj, key3, { enumerable: true, configurable: true, writable: true, value: value7 }) : obj[key3] = value7;
+      var __spreadValues = (a, b) => {
+        for (var prop in b || (b = {}))
+          if (__hasOwnProp.call(b, prop))
+            __defNormalProp(a, prop, b[prop]);
+        if (__getOwnPropSymbols)
+          for (var prop of __getOwnPropSymbols(b)) {
+            if (__propIsEnum.call(b, prop))
+              __defNormalProp(a, prop, b[prop]);
+          }
+        return a;
+      };
+      var __export2 = (target6, all) => {
+        for (var name9 in all)
+          __defProp(target6, name9, { get: all[name9], enumerable: true });
+      };
+      var __copyProps = (to2, from2, except, desc) => {
+        if (from2 && typeof from2 === "object" || typeof from2 === "function") {
+          for (let key3 of __getOwnPropNames(from2))
+            if (!__hasOwnProp.call(to2, key3) && key3 !== except)
+              __defProp(to2, key3, { get: () => from2[key3], enumerable: !(desc = __getOwnPropDesc(from2, key3)) || desc.enumerable });
+        }
+        return to2;
+      };
+      var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+      var __publicField = (obj, key3, value7) => {
+        __defNormalProp(obj, typeof key3 !== "symbol" ? key3 + "" : key3, value7);
+        return value7;
+      };
+      var src_exports = {};
+      __export2(src_exports, {
+        DEFAULT_OPTIONS: () => DEFAULT_OPTIONS,
+        DEFAULT_UUID_LENGTH: () => DEFAULT_UUID_LENGTH,
+        default: () => ShortUniqueId3
+      });
+      var version6 = "5.2.0";
+      var DEFAULT_UUID_LENGTH = 6;
+      var DEFAULT_OPTIONS = {
+        dictionary: "alphanum",
+        shuffle: true,
+        debug: false,
+        length: DEFAULT_UUID_LENGTH,
+        counter: 0
+      };
+      var _ShortUniqueId = class _ShortUniqueId {
+        constructor(argOptions = {}) {
+          __publicField(this, "counter");
+          __publicField(this, "debug");
+          __publicField(this, "dict");
+          __publicField(this, "version");
+          __publicField(this, "dictIndex", 0);
+          __publicField(this, "dictRange", []);
+          __publicField(this, "lowerBound", 0);
+          __publicField(this, "upperBound", 0);
+          __publicField(this, "dictLength", 0);
+          __publicField(this, "uuidLength");
+          __publicField(this, "_digit_first_ascii", 48);
+          __publicField(this, "_digit_last_ascii", 58);
+          __publicField(this, "_alpha_lower_first_ascii", 97);
+          __publicField(this, "_alpha_lower_last_ascii", 123);
+          __publicField(this, "_hex_last_ascii", 103);
+          __publicField(this, "_alpha_upper_first_ascii", 65);
+          __publicField(this, "_alpha_upper_last_ascii", 91);
+          __publicField(this, "_number_dict_ranges", {
+            digits: [this._digit_first_ascii, this._digit_last_ascii]
+          });
+          __publicField(this, "_alpha_dict_ranges", {
+            lowerCase: [this._alpha_lower_first_ascii, this._alpha_lower_last_ascii],
+            upperCase: [this._alpha_upper_first_ascii, this._alpha_upper_last_ascii]
+          });
+          __publicField(this, "_alpha_lower_dict_ranges", {
+            lowerCase: [this._alpha_lower_first_ascii, this._alpha_lower_last_ascii]
+          });
+          __publicField(this, "_alpha_upper_dict_ranges", {
+            upperCase: [this._alpha_upper_first_ascii, this._alpha_upper_last_ascii]
+          });
+          __publicField(this, "_alphanum_dict_ranges", {
+            digits: [this._digit_first_ascii, this._digit_last_ascii],
+            lowerCase: [this._alpha_lower_first_ascii, this._alpha_lower_last_ascii],
+            upperCase: [this._alpha_upper_first_ascii, this._alpha_upper_last_ascii]
+          });
+          __publicField(this, "_alphanum_lower_dict_ranges", {
+            digits: [this._digit_first_ascii, this._digit_last_ascii],
+            lowerCase: [this._alpha_lower_first_ascii, this._alpha_lower_last_ascii]
+          });
+          __publicField(this, "_alphanum_upper_dict_ranges", {
+            digits: [this._digit_first_ascii, this._digit_last_ascii],
+            upperCase: [this._alpha_upper_first_ascii, this._alpha_upper_last_ascii]
+          });
+          __publicField(this, "_hex_dict_ranges", {
+            decDigits: [this._digit_first_ascii, this._digit_last_ascii],
+            alphaDigits: [this._alpha_lower_first_ascii, this._hex_last_ascii]
+          });
+          __publicField(this, "_dict_ranges", {
+            _number_dict_ranges: this._number_dict_ranges,
+            _alpha_dict_ranges: this._alpha_dict_ranges,
+            _alpha_lower_dict_ranges: this._alpha_lower_dict_ranges,
+            _alpha_upper_dict_ranges: this._alpha_upper_dict_ranges,
+            _alphanum_dict_ranges: this._alphanum_dict_ranges,
+            _alphanum_lower_dict_ranges: this._alphanum_lower_dict_ranges,
+            _alphanum_upper_dict_ranges: this._alphanum_upper_dict_ranges,
+            _hex_dict_ranges: this._hex_dict_ranges
+          });
+          __publicField(this, "log", (...args) => {
+            const finalArgs = [...args];
+            finalArgs[0] = `[short-unique-id] ${args[0]}`;
+            if (this.debug === true) {
+              if (typeof console !== "undefined" && console !== null) {
+                return console.log(...finalArgs);
+              }
+            }
+          });
+          __publicField(this, "_normalizeDictionary", (dictionary2, shuffle2) => {
+            let finalDict;
+            if (dictionary2 && Array.isArray(dictionary2) && dictionary2.length > 1) {
+              finalDict = dictionary2;
+            } else {
+              finalDict = [];
+              let i;
+              this.dictIndex = i = 0;
+              const rangesName = `_${dictionary2}_dict_ranges`;
+              const ranges = this._dict_ranges[rangesName];
+              Object.keys(ranges).forEach((rangeType) => {
+                const rangeTypeKey = rangeType;
+                this.dictRange = ranges[rangeTypeKey];
+                this.lowerBound = this.dictRange[0];
+                this.upperBound = this.dictRange[1];
+                for (this.dictIndex = i = this.lowerBound; this.lowerBound <= this.upperBound ? i < this.upperBound : i > this.upperBound; this.dictIndex = this.lowerBound <= this.upperBound ? i += 1 : i -= 1) {
+                  finalDict.push(String.fromCharCode(this.dictIndex));
+                }
+              });
+            }
+            if (shuffle2) {
+              const PROBABILITY = 0.5;
+              finalDict = finalDict.sort(() => Math.random() - PROBABILITY);
+            }
+            return finalDict;
+          });
+          __publicField(this, "setDictionary", (dictionary2, shuffle2) => {
+            this.dict = this._normalizeDictionary(dictionary2, shuffle2);
+            this.dictLength = this.dict.length;
+            this.setCounter(0);
+          });
+          __publicField(this, "seq", () => {
+            return this.sequentialUUID();
+          });
+          __publicField(this, "sequentialUUID", () => {
+            let counterDiv;
+            let counterRem;
+            let id4 = "";
+            counterDiv = this.counter;
+            do {
+              counterRem = counterDiv % this.dictLength;
+              counterDiv = Math.trunc(counterDiv / this.dictLength);
+              id4 += this.dict[counterRem];
+            } while (counterDiv !== 0);
+            this.counter += 1;
+            return id4;
+          });
+          __publicField(this, "rnd", (uuidLength = this.uuidLength || DEFAULT_UUID_LENGTH) => {
+            return this.randomUUID(uuidLength);
+          });
+          __publicField(this, "randomUUID", (uuidLength = this.uuidLength || DEFAULT_UUID_LENGTH) => {
+            let id4;
+            let randomPartIdx;
+            let j;
+            if (uuidLength === null || typeof uuidLength === "undefined" || uuidLength < 1) {
+              throw new Error("Invalid UUID Length Provided");
+            }
+            id4 = "";
+            for (j = 0; j < uuidLength; j += 1) {
+              randomPartIdx = parseInt(
+                (Math.random() * this.dictLength).toFixed(0),
+                10
+              ) % this.dictLength;
+              id4 += this.dict[randomPartIdx];
+            }
+            return id4;
+          });
+          __publicField(this, "fmt", (format4, date6) => {
+            return this.formattedUUID(format4, date6);
+          });
+          __publicField(this, "formattedUUID", (format4, date6) => {
+            const fnMap = {
+              "$r": this.randomUUID,
+              "$s": this.sequentialUUID,
+              "$t": this.stamp
+            };
+            const result6 = format4.replace(
+              /\$[rs]\d{0,}|\$t0|\$t[1-9]\d{1,}/g,
+              (m) => {
+                const fn2 = m.slice(0, 2);
+                const len = parseInt(m.slice(2), 10);
+                if (fn2 === "$s") {
+                  return fnMap[fn2]().padStart(len, "0");
+                }
+                if (fn2 === "$t" && date6) {
+                  return fnMap[fn2](len, date6);
+                }
+                return fnMap[fn2](len);
+              }
+            );
+            return result6;
+          });
+          __publicField(this, "availableUUIDs", (uuidLength = this.uuidLength) => {
+            return parseFloat(
+              Math.pow([...new Set(this.dict)].length, uuidLength).toFixed(0)
+            );
+          });
+          __publicField(this, "approxMaxBeforeCollision", (rounds = this.availableUUIDs(this.uuidLength)) => {
+            return parseFloat(
+              Math.sqrt(Math.PI / 2 * rounds).toFixed(20)
+            );
+          });
+          __publicField(this, "collisionProbability", (rounds = this.availableUUIDs(this.uuidLength), uuidLength = this.uuidLength) => {
+            return parseFloat(
+              (this.approxMaxBeforeCollision(rounds) / this.availableUUIDs(uuidLength)).toFixed(20)
+            );
+          });
+          __publicField(this, "uniqueness", (rounds = this.availableUUIDs(this.uuidLength)) => {
+            const score2 = parseFloat(
+              (1 - this.approxMaxBeforeCollision(rounds) / rounds).toFixed(20)
+            );
+            return score2 > 1 ? 1 : score2 < 0 ? 0 : score2;
+          });
+          __publicField(this, "getVersion", () => {
+            return this.version;
+          });
+          __publicField(this, "stamp", (finalLength, date6) => {
+            const hexStamp = Math.floor(+(date6 || /* @__PURE__ */ new Date()) / 1e3).toString(16);
+            if (typeof finalLength === "number" && finalLength === 0) {
+              return hexStamp;
+            }
+            if (typeof finalLength !== "number" || finalLength < 10) {
+              throw new Error(
+                [
+                  "Param finalLength must be a number greater than or equal to 10,",
+                  "or 0 if you want the raw hexadecimal timestamp"
+                ].join("\n")
+              );
+            }
+            const idLength = finalLength - 9;
+            const rndIdx = Math.round(Math.random() * (idLength > 15 ? 15 : idLength));
+            const id4 = this.randomUUID(idLength);
+            return `${id4.substring(0, rndIdx)}${hexStamp}${id4.substring(rndIdx)}${rndIdx.toString(16)}`;
+          });
+          __publicField(this, "parseStamp", (suid, format4) => {
+            if (format4 && !/t0|t[1-9]\d{1,}/.test(format4)) {
+              throw new Error("Cannot extract date from a formated UUID with no timestamp in the format");
+            }
+            const stamp = format4 ? format4.replace(
+              /\$[rs]\d{0,}|\$t0|\$t[1-9]\d{1,}/g,
+              (m) => {
+                const fnMap = {
+                  "$r": (len2) => [...Array(len2)].map(() => "r").join(""),
+                  "$s": (len2) => [...Array(len2)].map(() => "s").join(""),
+                  "$t": (len2) => [...Array(len2)].map(() => "t").join("")
+                };
+                const fn2 = m.slice(0, 2);
+                const len = parseInt(m.slice(2), 10);
+                return fnMap[fn2](len);
+              }
+            ).replace(
+              /^(.*?)(t{8,})(.*)$/g,
+              (_m, p1, p2) => {
+                return suid.substring(p1.length, p1.length + p2.length);
+              }
+            ) : suid;
+            if (stamp.length === 8) {
+              return new Date(parseInt(stamp, 16) * 1e3);
+            }
+            if (stamp.length < 10) {
+              throw new Error("Stamp length invalid");
+            }
+            const rndIdx = parseInt(stamp.substring(stamp.length - 1), 16);
+            return new Date(parseInt(stamp.substring(rndIdx, rndIdx + 8), 16) * 1e3);
+          });
+          __publicField(this, "setCounter", (counter2) => {
+            this.counter = counter2;
+          });
+          __publicField(this, "validate", (uid4, dictionary2) => {
+            const finalDictionary = dictionary2 ? this._normalizeDictionary(dictionary2) : this.dict;
+            return uid4.split("").every((c) => finalDictionary.includes(c));
+          });
+          const options = __spreadValues(__spreadValues({}, DEFAULT_OPTIONS), argOptions);
+          this.counter = 0;
+          this.debug = false;
+          this.dict = [];
+          this.version = version6;
+          const {
+            dictionary,
+            shuffle,
+            length: length3,
+            counter
+          } = options;
+          this.uuidLength = length3;
+          this.setDictionary(dictionary, shuffle);
+          this.setCounter(counter);
+          this.debug = options.debug;
+          this.log(this.dict);
+          this.log(
+            `Generator instantiated with Dictionary Size ${this.dictLength} and counter set to ${this.counter}`
+          );
+          this.log = this.log.bind(this);
+          this.setDictionary = this.setDictionary.bind(this);
+          this.setCounter = this.setCounter.bind(this);
+          this.seq = this.seq.bind(this);
+          this.sequentialUUID = this.sequentialUUID.bind(this);
+          this.rnd = this.rnd.bind(this);
+          this.randomUUID = this.randomUUID.bind(this);
+          this.fmt = this.fmt.bind(this);
+          this.formattedUUID = this.formattedUUID.bind(this);
+          this.availableUUIDs = this.availableUUIDs.bind(this);
+          this.approxMaxBeforeCollision = this.approxMaxBeforeCollision.bind(this);
+          this.collisionProbability = this.collisionProbability.bind(this);
+          this.uniqueness = this.uniqueness.bind(this);
+          this.getVersion = this.getVersion.bind(this);
+          this.stamp = this.stamp.bind(this);
+          this.parseStamp = this.parseStamp.bind(this);
+          return this;
+        }
+      };
+      __publicField(_ShortUniqueId, "default", _ShortUniqueId);
+      var ShortUniqueId3 = _ShortUniqueId;
+      return __toCommonJS(src_exports);
+    })();
+    "undefined" != typeof module3 && (module3.exports = ShortUniqueId2.default), "undefined" != typeof window && (ShortUniqueId2 = ShortUniqueId2.default);
+  }
+});
+
 // ../node_modules/slugify/slugify.js
 var require_slugify = __commonJS({
   "../node_modules/slugify/slugify.js"(exports, module3) {
@@ -21914,7 +21914,7 @@ function listToCollection(kb, obj) {
 }
 async function jsonldParser(str, kb, base2) {
   const baseString = base2 && Object.prototype.hasOwnProperty.call(base2, "termType") ? base2.value : base2;
-  const jsonld = await import('./jsonld-V2RB47OZ-CaIJ08AA.js');
+  const jsonld = await import('./jsonld-V2RB47OZ-CWZbzWzV.js');
   const flattened = await jsonld.default.flatten(JSON.parse(str), null, {
     base: baseString
   });
@@ -27614,8 +27614,8 @@ var Thing = class {
    * Retrieves a list of RDF types for this thing.
    */
   types() {
-    const uriMap = this.store.findTypeURIs(namedNode(this.uri));
-    return Object.keys(uriMap).map((uri6) => ({
+    const uris = this.store.findTypes(this.uri);
+    return uris.map((uri6) => ({
       uri: uri6,
       label: labelForType(uri6)
     }));
@@ -27772,6 +27772,203 @@ var PictureGateway = class {
   }
 };
 
+// src/profile/WebIdProfile.ts
+var WebIdProfile = class extends Thing {
+  constructor(webId, store, editable = false) {
+    super(webId, store, editable);
+    this.webId = webId;
+    this.store = store;
+    this.editable = editable;
+    this.profileQuery = this.store.profileQuery(this.webId);
+  }
+  /**
+   * Returns the URI of the preferences document
+   */
+  getPreferencesFile() {
+    return this.profileQuery.queryPreferencesFile()?.value;
+  }
+  /**
+   * Returns the URI of the public type index document
+   * @since 0.24.0
+   */
+  getPublicTypeIndex() {
+    return this.profileQuery.queryPublicTypeIndex()?.value;
+  }
+  /**
+   * Returns the URI of the private type index document
+   * @since 0.24.0
+   */
+  getPrivateTypeIndex() {
+    const preferences = this.profileQuery.queryPreferencesFile();
+    if (!preferences) return void 0;
+    const query4 = this.store.preferencesQuery(this.webId, preferences);
+    return query4.queryPrivateTypeIndex()?.value;
+  }
+  /**
+   * Returns the URIs of the private label indexes
+   */
+  getPrivateLabelIndexes() {
+    const profileNodes = this.store.each(
+      namedNode(this.webId),
+      namedNode("http://www.w3.org/ns/solid/terms#privateLabelIndex"),
+      void 0,
+      namedNode(this.webId).doc()
+    );
+    const preferences = this.getPreferencesFile();
+    if (preferences) {
+      const preferencesNodes = this.store.each(
+        namedNode(this.webId),
+        namedNode("http://www.w3.org/ns/solid/terms#privateLabelIndex"),
+        void 0,
+        namedNode(preferences)
+      );
+      return [...profileNodes, ...preferencesNodes].map((it) => it.value);
+    } else {
+      return profileNodes.map((it) => it.value);
+    }
+  }
+};
+
+// src/profile/ProfileGateway.ts
+var ProfileGateway = class {
+  constructor(store) {
+    this.store = store;
+  }
+  /**
+   * Fetches the profile for the given WebID and all linked documents
+   * @since 0.24.0
+   * @param webId The WebID to fetch the profile for
+   * @returns {Promise<WebIdProfile>} The fetched profile
+   */
+  async fetchProfile(webId) {
+    await this.store.fetch(webId);
+    const profile2 = this.store.get(webId).assume(WebIdProfile);
+    const preferences = profile2.getPreferencesFile();
+    if (preferences) {
+      try {
+        await this.store.fetch(preferences);
+      } catch (error4) {
+        console.warn(`Failed to fetch preferences file ${preferences}:`, error4);
+      }
+    }
+    const publicTypeIndex2 = profile2.getPublicTypeIndex();
+    const privateTypeIndex2 = profile2.getPrivateTypeIndex();
+    await this.store.fetchAll(
+      [privateTypeIndex2, publicTypeIndex2].filter((it) => it !== void 0)
+    );
+    return profile2;
+  }
+};
+
+// src/search/SearchIndex.ts
+var import_lunr = __toESM(require_lunr(), 1);
+var SearchIndex = class {
+  constructor(labelIndexes) {
+    this.labelIndexes = labelIndexes;
+    this.index = this.rebuild().index;
+  }
+  /**
+   * Recreates the search index with the current data from all label indexes
+   */
+  rebuild() {
+    const labelIndexes = this.labelIndexes;
+    this.index = (0, import_lunr.default)(function() {
+      this.ref("uri");
+      this.field("uri");
+      this.field("label");
+      this.metadataWhitelist = ["position"];
+      const items2 = labelIndexes.flatMap((it) => it.getIndexedItems());
+      items2.forEach((item4) => {
+        this.add({
+          uri: item4.uri,
+          label: item4.label
+        });
+      });
+    });
+    return this;
+  }
+  /**
+   * Search the index for a given term. It finds partial matches, but will rank exact matches higher.
+   *
+   * The rank order is:
+   *
+   *  1. exact matches
+   *  2. prefix matches
+   *  3. suffix matches
+   *  4. any matches inside a literal
+   *
+   * @param term The (partial) term to search for
+   * @param maxResults The maximum number of results to return (defaults to 10)
+   */
+  search(term3, maxResults = 10) {
+    const escapedTerm = term3.replace(/[~^+:]/g, (x) => `\\${x}`);
+    return this.index.search(
+      `${escapedTerm}^100 ${escapedTerm}*^20 *${escapedTerm}^10 *${escapedTerm}*^5`
+    ).slice(0, maxResults);
+  }
+  /**
+   * Remove all data from the search index.
+   */
+  clear() {
+    this.index = (0, import_lunr.default)(() => {
+    });
+  }
+};
+
+// src/rdf-document/RdfDocument.ts
+var RdfDocument = class extends Thing {
+  constructor(uri6, store, editable = false) {
+    super(uri6, store, editable);
+    this.uri = uri6;
+    this.store = store;
+    this.editable = editable;
+  }
+  subjects() {
+    const matches = this.store.statementsMatching(
+      null,
+      null,
+      null,
+      namedNode(this.uri)
+    );
+    const uris = matches.filter((match) => isNamedNode(match.subject)).map((match) => match.subject.value);
+    const uniqueUris = new Set(uris);
+    uniqueUris.delete(this.uri);
+    return [...uniqueUris].map((uri6) => ({
+      uri: uri6
+    }));
+  }
+};
+
+// src/search/LabelIndex.ts
+var LabelIndex = class extends RdfDocument {
+  constructor(uri6, store, editable = false) {
+    super(uri6, store, editable);
+    this.uri = uri6;
+    this.store = store;
+    this.editable = editable;
+  }
+  /**
+   * Returns the URIs and labels for all the things listed in the document.
+   */
+  getIndexedItems() {
+    const matches = this.store.statementsMatching(
+      null,
+      rdfs("label"),
+      null,
+      namedNode(this.uri)
+    );
+    return matches.map((it) => {
+      return {
+        uri: it.subject.value,
+        label: it.object.value
+      };
+    });
+  }
+  contains(uri6) {
+    return this.store.holds(namedNode(uri6), rdfs("label"), null, namedNode(this.uri));
+  }
+};
+
 // node_modules/@solid-data-modules/rdflib-utils/dist/web-operations/executeUpdate.js
 async function executeUpdate(fetcher2, updater, operation3) {
   await updater.updateMany(operation3.deletions, operation3.insertions);
@@ -27839,207 +28036,6 @@ var ProfileQuery = class {
 var import_short_unique_id = __toESM(require_short_unique_id(), 1);
 new import_short_unique_id.default({ length: 10 });
 
-// src/profile/WebIdProfile.ts
-var WebIdProfile = class extends Thing {
-  constructor(webId, store, editable = false) {
-    super(webId, store, editable);
-    this.webId = webId;
-    this.store = store;
-    this.editable = editable;
-    this.profileQuery = new ProfileQuery(namedNode(this.webId), this.store);
-  }
-  /**
-   * Returns the URI of the preferences document
-   */
-  getPreferencesFile() {
-    return this.profileQuery.queryPreferencesFile()?.value;
-  }
-  /**
-   * Returns the URI of the public type index document
-   * @since 0.24.0
-   */
-  getPublicTypeIndex() {
-    return this.profileQuery.queryPublicTypeIndex()?.value;
-  }
-  /**
-   * Returns the URI of the private type index document
-   * @since 0.24.0
-   */
-  getPrivateTypeIndex() {
-    const preferences = this.profileQuery.queryPreferencesFile();
-    if (!preferences) return void 0;
-    const query4 = new PreferencesQuery(
-      this.store,
-      namedNode(this.webId),
-      preferences
-    );
-    return query4.queryPrivateTypeIndex()?.value;
-  }
-  /**
-   * Returns the URIs of the private label indexes
-   */
-  getPrivateLabelIndexes() {
-    const profileNodes = this.store.each(
-      namedNode(this.webId),
-      namedNode("http://www.w3.org/ns/solid/terms#privateLabelIndex"),
-      void 0,
-      namedNode(this.webId).doc()
-    );
-    const preferences = this.getPreferencesFile();
-    if (preferences) {
-      const preferencesNodes = this.store.each(
-        namedNode(this.webId),
-        namedNode("http://www.w3.org/ns/solid/terms#privateLabelIndex"),
-        void 0,
-        namedNode(preferences)
-      );
-      return [...profileNodes, ...preferencesNodes].map((it) => it.value);
-    } else {
-      return profileNodes.map((it) => it.value);
-    }
-  }
-};
-
-// src/profile/ProfileGateway.ts
-var ProfileGateway = class {
-  constructor(store) {
-    this.store = store;
-  }
-  /**
-   * Fetches the profile for the given WebID and all linked documents
-   * @since 0.24.0
-   * @param webId The WebID to fetch the profile for
-   * @returns {Promise<WebIdProfile>} The fetched profile
-   */
-  async fetchProfile(webId) {
-    await this.store.fetch(webId);
-    const profile2 = this.store.get(webId).assume(WebIdProfile);
-    const preferences = profile2.getPreferencesFile();
-    if (preferences) {
-      try {
-        await this.store.fetch(preferences);
-      } catch (error4) {
-        console.warn(`Failed to fetch preferences file ${preferences}:`, error4);
-      }
-    }
-    const publicTypeIndex2 = profile2.getPublicTypeIndex();
-    const privateTypeIndex2 = profile2.getPrivateTypeIndex();
-    await this.store.fetchAll(
-      [privateTypeIndex2, publicTypeIndex2].filter((it) => it !== void 0)
-    );
-    return profile2;
-  }
-};
-
-// src/search/SearchIndex.ts
-var import_lunr = __toESM(require_lunr(), 1);
-var SearchIndex = class {
-  constructor(labelIndexes) {
-    this.labelIndexes = labelIndexes;
-    this.index = this.rebuild().index;
-  }
-  /**
-   * Recreates the search index with the current data from all label indexes
-   */
-  rebuild() {
-    const labelIndexes = this.labelIndexes;
-    this.index = (0, import_lunr.default)(function() {
-      this.ref("uri");
-      this.field("uri");
-      this.field("label");
-      this.metadataWhitelist = ["position"];
-      const items2 = labelIndexes.flatMap((it) => it.getIndexedItems());
-      items2.forEach((item4) => {
-        this.add({
-          uri: item4.uri,
-          label: item4.label
-        });
-      });
-    });
-    return this;
-  }
-  /**
-   * Search the index for a given term. It finds partial matches, but will rank exact matches higher.
-   *
-   * The rank order is:
-   *
-   *  1. exact matches
-   *  2. prefix matches
-   *  3. suffix matches
-   *  4. any matches inside a literal
-   *
-   * @param term The (partial) term to search for
-   * @param maxResults The maximum number of results to return (defaults to 10)
-   */
-  search(term3, maxResults = 10) {
-    const escapedTerm = term3.replace(/[~^+:]/g, (x) => `\\${x}`);
-    return this.index.search(
-      `${escapedTerm}^100 ${escapedTerm}*^20 *${escapedTerm}^10 *${escapedTerm}*^5`
-    ).slice(0, maxResults);
-  }
-  /**
-   * Remove all data from the search index.
-   */
-  clear() {
-    this.index = (0, import_lunr.default)(() => {
-    });
-  }
-};
-
-// src/rdf-document/RdfDocument.ts
-var RdfDocument = class extends Thing {
-  constructor(uri6, store, editable = false) {
-    super(uri6, store, editable);
-    this.uri = uri6;
-    this.store = store;
-    this.editable = editable;
-  }
-  subjects() {
-    const matches = this.store.statementsMatching(
-      null,
-      null,
-      null,
-      namedNode(this.uri)
-    );
-    const uris = matches.filter((match) => isNamedNode(match.subject)).map((match) => match.subject.value);
-    const uniqueUris = new Set(uris);
-    uniqueUris.delete(this.uri);
-    return [...uniqueUris].map((uri6) => ({
-      uri: uri6
-    }));
-  }
-};
-
-// src/search/LabelIndex.ts
-var LabelIndex = class extends RdfDocument {
-  constructor(uri6, store, editable = false) {
-    super(uri6, store, editable);
-    this.uri = uri6;
-    this.store = store;
-    this.editable = editable;
-  }
-  /**
-   * Returns the URIs and labels for all the things listed in the document.
-   */
-  getIndexedItems() {
-    const matches = this.store.statementsMatching(
-      null,
-      rdfs("label"),
-      null,
-      namedNode(this.uri)
-    );
-    return matches.map((it) => {
-      return {
-        uri: it.subject.value,
-        label: it.object.value
-      };
-    });
-  }
-  contains(uri6) {
-    return this.store.holds(namedNode(uri6), rdfs("label"), null, namedNode(this.uri));
-  }
-};
-
 // src/search/createDefaultLabelIndex.ts
 function createDefaultLabelIndex(profile2) {
   const webId = namedNode(profile2.webId);
@@ -28240,7 +28236,7 @@ var Store = class {
    */
   get(uri6) {
     const editable = !!this.updater.editable(uri6);
-    return new Thing(uri6, this.internalStore, editable);
+    return new Thing(uri6, this, editable);
   }
   /**
    * Adds a new value to the property of the given thing
@@ -28323,6 +28319,139 @@ var Store = class {
       distinctUntilChanged((prev2, curr) => prev2.length == curr.length)
     );
   }
+  /**
+   * Finds types of the given resource
+   *
+   * @param {string|NamedNode|BlankNode} uri String or RDF/JS object
+   * @returns {string[]} An array of URIs of types
+   */
+  findTypes(uri6) {
+    if (typeof uri6 === "string") uri6 = namedNode(uri6);
+    return Object.keys(this.internalStore.findTypeURIs(uri6));
+  }
+  /**
+   * Determines whether the store includes a certain quad pattern, returning true or false as appropriate.
+   *
+   * @param {Quad_Subject|null|undefined} subject
+   * @param {Quad_Predicate|null|undefined} predicate
+   * @param {Quad_Object|null|undefined} object
+   * @param {Quad_Graph|null|undefined} graph
+   * @returns {boolean} Whether the store includes the quad pattern
+   */
+  holds(subject8, predicate4, object8, graph3) {
+    return this.internalStore.holds(subject8, predicate4, object8, graph3);
+  }
+  /**
+   * Statements matching the provided quad pattern
+   *
+   * @param {Quad_Subject|null|undefined} subject
+   * @param {Quad_Predicate|null|undefined} predicate
+   * @param {Quad_Object|null|undefined} object
+   * @param {Quad_Graph|null|undefined} graph
+   * @returns {Quad[]} Array of statements
+   */
+  statementsMatching(subject8, predicate4, object8, graph3) {
+    return this.internalStore.statementsMatching(
+      subject8,
+      predicate4,
+      object8,
+      graph3
+    );
+  }
+  /**
+   * RDF/JS terms matching the first wildcard in the provided quad pattern
+   *
+   * @param {Quad_Subject|null|undefined} subject
+   * @param {Quad_Predicate|null|undefined} predicate
+   * @param {Quad_Object|null|undefined} object
+   * @param {Quad_Graph|null|undefined} graph
+   * @returns {Term[]} Array of terms
+   */
+  each(subject8, predicate4, object8, graph3) {
+    const statements = this.statementsMatching(
+      subject8,
+      predicate4,
+      object8,
+      graph3
+    );
+    if (!subject8) {
+      return statements.map((statement2) => statement2.subject);
+    } else if (!predicate4) {
+      return statements.map((statement2) => statement2.predicate);
+    } else if (!object8) {
+      return statements.map((statement2) => statement2.object);
+    } else if (!graph3) {
+      return statements.map((statement2) => statement2.graph);
+    }
+    throw new Error("No wildcard specified");
+  }
+  /**
+   * Any one RDF/JS term matching the first wildcard in the provided quad pattern
+   *
+   * @param {Quad_Subject|null|undefined} subject
+   * @param {Quad_Predicate|null|undefined} predicate
+   * @param {Quad_Object|null|undefined} object
+   * @param {Quad_Graph|null|undefined} graph
+   * @returns {Term | null} RDF/JS term
+   */
+  any(subject8, predicate4, object8, graph3) {
+    const justOne = true;
+    const statements = this.internalStore.statementsMatching(
+      subject8,
+      predicate4,
+      object8,
+      graph3,
+      justOne
+    );
+    if (statements.length == 0) return null;
+    if (!subject8) {
+      return statements[0].subject;
+    } else if (!predicate4) {
+      return statements[0].predicate;
+    } else if (!object8) {
+      return statements[0].object;
+    } else if (!graph3) {
+      return statements[0].graph;
+    }
+    throw new Error("No wildcard specified");
+  }
+  /**
+   * Value of any one RDF/JS term matching the first wildcard in the provided quad pattern
+   *
+   * @param {Quad_Subject|null|undefined} subject
+   * @param {Quad_Predicate|null|undefined} predicate
+   * @param {Quad_Object|null|undefined} object
+   * @param {Quad_Graph|null|undefined} graph
+   * @returns {string | undefined} value of RDF/JS term
+   */
+  anyValue(subject8, predicate4, object8, graph3) {
+    return this.any(subject8, predicate4, object8, graph3)?.value;
+  }
+  /**
+     * Create a query to fetch information from a user's preferences file
+     * 
+     * @param webId 
+     * @param preferencesDoc 
+     * @returns {PreferencesQuery} PreferencesQuery instance. See [@solid-data-modules/rdflib-utils
+  ](https://solid-contrib.github.io/data-modules/rdflib-utils/classes/index.PreferencesQuery.html)
+     */
+  preferencesQuery(webId, preferencesDoc) {
+    if (typeof webId === "string") webId = namedNode(webId);
+    if (typeof preferencesDoc === "string")
+      preferencesDoc = namedNode(preferencesDoc);
+    return new PreferencesQuery(this.internalStore, webId, preferencesDoc);
+  }
+  /**
+     * Create a query to fetch information from a user's profile document
+     * 
+     * @param webId 
+     * @returns {ProfileQuery} ProfileQuery instance. See [@solid-data-modules/rdflib-utils
+  ](https://solid-contrib.github.io/data-modules/rdflib-utils/classes/index.ProfileQuery.html)
+     */
+  profileQuery(webId) {
+    if (typeof webId === "string") webId = namedNode(webId);
+    return new ProfileQuery(webId, this.internalStore);
+  }
 };
 
 // ../node_modules/rdf-namespaces/dist/index.es.js
@@ -38262,7 +38391,7 @@ var langString = "http://www.w3.org/1999/02/22-rdf-syntax-ns#langString";
 var PlainLiteral = "http://www.w3.org/1999/02/22-rdf-syntax-ns#PlainLiteral";
 var type4 = "http://www.w3.org/1999/02/22-rdf-syntax-ns#type";
 var Property2 = "http://www.w3.org/1999/02/22-rdf-syntax-ns#Property";
-var Statement2 = "http://www.w3.org/1999/02/22-rdf-syntax-ns#Statement";
+var Statement3 = "http://www.w3.org/1999/02/22-rdf-syntax-ns#Statement";
 var subject5 = "http://www.w3.org/1999/02/22-rdf-syntax-ns#subject";
 var predicate = "http://www.w3.org/1999/02/22-rdf-syntax-ns#predicate";
 var object3 = "http://www.w3.org/1999/02/22-rdf-syntax-ns#object";
@@ -38284,7 +38413,7 @@ var rdfImport = /* @__PURE__ */ Object.freeze({
   PlainLiteral,
   type: type4,
   Property: Property2,
-  Statement: Statement2,
+  Statement: Statement3,
   subject: subject5,
   predicate,
   object: object3,
@@ -39161,7 +39290,7 @@ var SportsTeam = "http://schema.org/SportsTeam";
 var SpreadsheetDigitalDocument = "http://schema.org/SpreadsheetDigitalDocument";
 var StadiumOrArena = "http://schema.org/StadiumOrArena";
 var State = "http://schema.org/State";
-var Statement3 = "http://schema.org/Statement";
+var Statement4 = "http://schema.org/Statement";
 var StatisticalPopulation = "http://schema.org/StatisticalPopulation";
 var StatisticalVariable = "http://schema.org/StatisticalVariable";
 var StatusEnumeration = "http://schema.org/StatusEnumeration";
@@ -41600,7 +41729,7 @@ var schemaImport = /* @__PURE__ */ Object.freeze({
   SpreadsheetDigitalDocument,
   StadiumOrArena,
   State,
-  Statement: Statement3,
+  Statement: Statement4,
   StatisticalPopulation,
   StatisticalVariable,
   StatusEnumeration,
@@ -44041,7 +44170,7 @@ var SportsTeam2 = "https://schema.org/SportsTeam";
 var SpreadsheetDigitalDocument2 = "https://schema.org/SpreadsheetDigitalDocument";
 var StadiumOrArena2 = "https://schema.org/StadiumOrArena";
 var State2 = "https://schema.org/State";
-var Statement4 = "https://schema.org/Statement";
+var Statement5 = "https://schema.org/Statement";
 var StatisticalPopulation2 = "https://schema.org/StatisticalPopulation";
 var StatisticalVariable2 = "https://schema.org/StatisticalVariable";
 var StatusEnumeration2 = "https://schema.org/StatusEnumeration";
@@ -46480,7 +46609,7 @@ var schema_httpsImport = /* @__PURE__ */ Object.freeze({
   SpreadsheetDigitalDocument: SpreadsheetDigitalDocument2,
   StadiumOrArena: StadiumOrArena2,
   State: State2,
-  Statement: Statement4,
+  Statement: Statement5,
   StatisticalPopulation: StatisticalPopulation2,
   StatisticalVariable: StatisticalVariable2,
   StatusEnumeration: StatusEnumeration2,
@@ -49659,6 +49788,181 @@ async function loadModule(moduleName, store) {
   return store.loadModule(module3);
 }
 
+// ../node_modules/url-template/lib/url-template.js
+function encodeReserved(str) {
+  return str.split(/(%[0-9A-Fa-f]{2})/g).map(function(part3) {
+    if (!/%[0-9A-Fa-f]/.test(part3)) {
+      part3 = encodeURI(part3).replace(/%5B/g, "[").replace(/%5D/g, "]");
+    }
+    return part3;
+  }).join("");
+}
+function encodeUnreserved(str) {
+  return encodeURIComponent(str).replace(/[!'()*]/g, function(c) {
+    return "%" + c.charCodeAt(0).toString(16).toUpperCase();
+  });
+}
+function encodeValue(operator2, value7, key3) {
+  value7 = operator2 === "+" || operator2 === "#" ? encodeReserved(value7) : encodeUnreserved(value7);
+  if (key3) {
+    return encodeUnreserved(key3) + "=" + value7;
+  } else {
+    return value7;
+  }
+}
+function isDefined(value7) {
+  return value7 !== void 0 && value7 !== null;
+}
+function isKeyOperator(operator2) {
+  return operator2 === ";" || operator2 === "&" || operator2 === "?";
+}
+function getValues(context4, operator2, key3, modifier2) {
+  var value7 = context4[key3], result6 = [];
+  if (isDefined(value7) && value7 !== "") {
+    if (typeof value7 === "string" || typeof value7 === "number" || typeof value7 === "boolean") {
+      value7 = value7.toString();
+      if (modifier2 && modifier2 !== "*") {
+        value7 = value7.substring(0, parseInt(modifier2, 10));
+      }
+      result6.push(encodeValue(operator2, value7, isKeyOperator(operator2) ? key3 : null));
+    } else {
+      if (modifier2 === "*") {
+        if (Array.isArray(value7)) {
+          value7.filter(isDefined).forEach(function(value8) {
+            result6.push(encodeValue(operator2, value8, isKeyOperator(operator2) ? key3 : null));
+          });
+        } else {
+          Object.keys(value7).forEach(function(k) {
+            if (isDefined(value7[k])) {
+              result6.push(encodeValue(operator2, value7[k], k));
+            }
+          });
+        }
+      } else {
+        var tmp = [];
+        if (Array.isArray(value7)) {
+          value7.filter(isDefined).forEach(function(value8) {
+            tmp.push(encodeValue(operator2, value8));
+          });
+        } else {
+          Object.keys(value7).forEach(function(k) {
+            if (isDefined(value7[k])) {
+              tmp.push(encodeUnreserved(k));
+              tmp.push(encodeValue(operator2, value7[k].toString()));
+            }
+          });
+        }
+        if (isKeyOperator(operator2)) {
+          result6.push(encodeUnreserved(key3) + "=" + tmp.join(","));
+        } else if (tmp.length !== 0) {
+          result6.push(tmp.join(","));
+        }
+      }
+    }
+  } else {
+    if (operator2 === ";") {
+      if (isDefined(value7)) {
+        result6.push(encodeUnreserved(key3));
+      }
+    } else if (value7 === "" && (operator2 === "&" || operator2 === "?")) {
+      result6.push(encodeUnreserved(key3) + "=");
+    } else if (value7 === "") {
+      result6.push("");
+    }
+  }
+  return result6;
+}
+function parseTemplate(template3) {
+  var operators = ["+", "#", ".", "/", ";", "?", "&"];
+  return {
+    expand: function(context4) {
+      return template3.replace(/\{([^\{\}]+)\}|([^\{\}]+)/g, function(_, expression4, literal4) {
+        if (expression4) {
+          var operator2 = null, values2 = [];
+          if (operators.indexOf(expression4.charAt(0)) !== -1) {
+            operator2 = expression4.charAt(0);
+            expression4 = expression4.substr(1);
+          }
+          expression4.split(/,/g).forEach(function(variable5) {
+            var tmp = /([^:\*]*)(?::(\d+)|(\*))?/.exec(variable5);
+            values2.push.apply(values2, getValues(context4, operator2, tmp[1], tmp[2] || tmp[3]));
+          });
+          if (operator2 && operator2 !== "+") {
+            var separator = ",";
+            if (operator2 === "?") {
+              separator = "&";
+            } else if (operator2 !== "#") {
+              separator = operator2;
+            }
+            return (values2.length !== 0 ? operator2 : "") + values2.join(separator);
+          } else {
+            return values2.join(",");
+          }
+        } else {
+          return encodeReserved(literal4);
+        }
+      });
+    }
+  };
+}
+
+// src/open-with/apps.ts
+var APPS = {
+  DATA_BROWSER: {
+    name: "Data Browser (SolidOS)",
+    urlTemplate: parseTemplate(
+      "https://solidos.github.io/mashlib/dist/browse.html{?uri}"
+    )
+  },
+  PENNY: {
+    name: "Penny",
+    urlTemplate: parseTemplate(
+      "https://penny.vincenttunru.com/explore/?url={uri}"
+    )
+  },
+  SOLID_FILE_MANAGER: {
+    name: "Solid File Manager",
+    urlTemplate: parseTemplate(
+      "https://otto-aa.github.io/solid-filemanager/?url={uri}"
+    )
+  },
+  UMAI: {
+    name: "Umai",
+    urlTemplate: parseTemplate(
+      "https://umai.noeldemartin.com/viewer?url={uri}"
+    )
+  },
+  DOKIELI: {
+    name: "dokieli",
+    urlTemplate: parseTemplate("https://dokie.li/#open={uri}")
+  },
+  DOKIELI_GRAPH: {
+    name: "dokieli Graph",
+    urlTemplate: parseTemplate("https://dokie.li/#graph={uri}")
+  },
+  POD_OS_CONTACTS: {
+    name: "PodOS Contacts",
+    urlTemplate: parseTemplate(
+      "https://contacts.pod-os.org/address-book{?uri}"
+    )
+  }
+};
+
+// src/open-with/proposeAppsFor.ts
+var appRegistrations = {
+  "http://www.w3.org/ns/ldp#Container": [APPS.SOLID_FILE_MANAGER],
+  "http://schema.org/Recipe": [APPS.UMAI],
+  "https://schema.org/Recipe": [APPS.UMAI],
+  "http://www.w3.org/2007/ont/link#RDFDocument": [APPS.DOKIELI_GRAPH],
+  "http://www.w3.org/ns/iana/media-types/text/html#Resource": [APPS.DOKIELI],
+  "http://www.w3.org/2006/vcard/ns#AddressBook": [APPS.POD_OS_CONTACTS]
+};
+function proposeAppsFor(thing) {
+  const apps = [APPS.DATA_BROWSER, APPS.PENNY];
+  const appsForType = thing.types().flatMap((it) => appRegistrations[it.uri]).filter((it) => it !== void 0);
+  return [...apps, ...appsForType];
+}
+
 // src/type-index/TypeIndex.ts
 var TypeIndex2 = class extends Thing {
   constructor(uri6, store, editable = false) {
@@ -49847,6 +50151,14 @@ var PodOS = class {
   attachments() {
     return this.attachmentGateway;
   }
+  /**
+   * Propose matching apps to open a thing
+   * @param thing - The thing to open
+   * @returns An array of apps that can open the thing. The array is empty if no apps are found.
+   */
+  proposeAppsFor(thing) {
+    return proposeAppsFor(thing);
+  }
 };
 /*! Bundled license information: