@pod-os/core 0.11.2-dec48f2.0 → 0.11.2-e654d19.0

package/lib/index.js

@@ -406,83 +406,6 @@ var PodOS = (() => {
     }
   });
 
-  // ../node_modules/uuid/dist/esm-browser/rng.js
-  function rng() {
-    if (!getRandomValues) {
-      getRandomValues = typeof crypto !== "undefined" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);
-      if (!getRandomValues) {
-        throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
-      }
-    }
-    return getRandomValues(rnds8);
-  }
-  var getRandomValues, rnds8;
-  var init_rng = __esm({
-    "../node_modules/uuid/dist/esm-browser/rng.js"() {
-      rnds8 = new Uint8Array(16);
-    }
-  });
-
-  // ../node_modules/uuid/dist/esm-browser/stringify.js
-  function unsafeStringify(arr, offset3 = 0) {
-    return byteToHex[arr[offset3 + 0]] + byteToHex[arr[offset3 + 1]] + byteToHex[arr[offset3 + 2]] + byteToHex[arr[offset3 + 3]] + "-" + byteToHex[arr[offset3 + 4]] + byteToHex[arr[offset3 + 5]] + "-" + byteToHex[arr[offset3 + 6]] + byteToHex[arr[offset3 + 7]] + "-" + byteToHex[arr[offset3 + 8]] + byteToHex[arr[offset3 + 9]] + "-" + byteToHex[arr[offset3 + 10]] + byteToHex[arr[offset3 + 11]] + byteToHex[arr[offset3 + 12]] + byteToHex[arr[offset3 + 13]] + byteToHex[arr[offset3 + 14]] + byteToHex[arr[offset3 + 15]];
-  }
-  var byteToHex;
-  var init_stringify = __esm({
-    "../node_modules/uuid/dist/esm-browser/stringify.js"() {
-      byteToHex = [];
-      for (let i = 0; i < 256; ++i) {
-        byteToHex.push((i + 256).toString(16).slice(1));
-      }
-    }
-  });
-
-  // ../node_modules/uuid/dist/esm-browser/native.js
-  var randomUUID, native_default;
-  var init_native = __esm({
-    "../node_modules/uuid/dist/esm-browser/native.js"() {
-      randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
-      native_default = {
-        randomUUID
-      };
-    }
-  });
-
-  // ../node_modules/uuid/dist/esm-browser/v4.js
-  function v4(options, buf, offset3) {
-    if (native_default.randomUUID && !buf && !options) {
-      return native_default.randomUUID();
-    }
-    options = options || {};
-    const rnds = options.random || (options.rng || rng)();
-    rnds[6] = rnds[6] & 15 | 64;
-    rnds[8] = rnds[8] & 63 | 128;
-    if (buf) {
-      offset3 = offset3 || 0;
-      for (let i = 0; i < 16; ++i) {
-        buf[offset3 + i] = rnds[i];
-      }
-      return buf;
-    }
-    return unsafeStringify(rnds);
-  }
-  var v4_default;
-  var init_v4 = __esm({
-    "../node_modules/uuid/dist/esm-browser/v4.js"() {
-      init_native();
-      init_rng();
-      init_stringify();
-      v4_default = v4;
-    }
-  });
-
-  // ../node_modules/uuid/dist/esm-browser/index.js
-  var init_esm_browser = __esm({
-    "../node_modules/uuid/dist/esm-browser/index.js"() {
-      init_v4();
-    }
-  });
-
   // ../node_modules/@inrupt/oidc-client/lib/oidc-client.min.js
   var require_oidc_client_min = __commonJS({
     "../node_modules/@inrupt/oidc-client/lib/oidc-client.min.js"(exports, module3) {
@@ -42495,23 +42418,372 @@ var PodOS = (() => {
   });
 
   // ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/namespaces.js
-  var rdf3, vcard, dc;
+  var rdf3, vcard, solid, pim, dc;
   var init_namespaces = __esm({
     "../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/namespaces.js"() {
       init_esm();
       rdf3 = Namespace("http://www.w3.org/1999/02/22-rdf-syntax-ns#");
       vcard = Namespace("http://www.w3.org/2006/vcard/ns#");
+      solid = Namespace("http://www.w3.org/ns/solid/terms#");
+      pim = Namespace("http://www.w3.org/ns/pim/space#");
       dc = Namespace("http://purl.org/dc/elements/1.1/");
     }
   });
 
+  // ../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) {
+      "use strict";
+      var ShortUniqueId2 = (() => {
+        var __defProp2 = Object.defineProperty;
+        var __getOwnPropDesc2 = Object.getOwnPropertyDescriptor;
+        var __getOwnPropNames2 = Object.getOwnPropertyNames;
+        var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+        var __hasOwnProp2 = Object.prototype.hasOwnProperty;
+        var __propIsEnum = Object.prototype.propertyIsEnumerable;
+        var __defNormalProp = (obj, key3, value6) => key3 in obj ? __defProp2(obj, key3, { enumerable: true, configurable: true, writable: true, value: value6 }) : obj[key3] = value6;
+        var __spreadValues = (a, b) => {
+          for (var prop in b || (b = {}))
+            if (__hasOwnProp2.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 = (target5, all) => {
+          for (var name7 in all)
+            __defProp2(target5, name7, { get: all[name7], enumerable: true });
+        };
+        var __copyProps2 = (to2, from, except, desc) => {
+          if (from && typeof from === "object" || typeof from === "function") {
+            for (let key3 of __getOwnPropNames2(from))
+              if (!__hasOwnProp2.call(to2, key3) && key3 !== except)
+                __defProp2(to2, key3, { get: () => from[key3], enumerable: !(desc = __getOwnPropDesc2(from, key3)) || desc.enumerable });
+          }
+          return to2;
+        };
+        var __toCommonJS2 = (mod) => __copyProps2(__defProp2({}, "__esModule", { value: true }), mod);
+        var __publicField = (obj, key3, value6) => {
+          __defNormalProp(obj, typeof key3 !== "symbol" ? key3 + "" : key3, value6);
+          return value6;
+        };
+        var src_exports2 = {};
+        __export2(src_exports2, {
+          DEFAULT_OPTIONS: () => DEFAULT_OPTIONS,
+          DEFAULT_UUID_LENGTH: () => DEFAULT_UUID_LENGTH,
+          default: () => ShortUniqueId3
+        });
+        var version6 = "5.0.3";
+        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, "setDictionary", (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);
+              }
+              this.dict = finalDict;
+              this.dictLength = this.dict.length;
+              this.setCounter(0);
+            });
+            __publicField(this, "seq", () => {
+              return this.sequentialUUID();
+            });
+            __publicField(this, "sequentialUUID", () => {
+              let counterDiv;
+              let counterRem;
+              let id6 = "";
+              counterDiv = this.counter;
+              do {
+                counterRem = counterDiv % this.dictLength;
+                counterDiv = Math.trunc(counterDiv / this.dictLength);
+                id6 += this.dict[counterRem];
+              } while (counterDiv !== 0);
+              this.counter += 1;
+              return id6;
+            });
+            __publicField(this, "rnd", (uuidLength = this.uuidLength || DEFAULT_UUID_LENGTH) => {
+              return this.randomUUID(uuidLength);
+            });
+            __publicField(this, "randomUUID", (uuidLength = this.uuidLength || DEFAULT_UUID_LENGTH) => {
+              let id6;
+              let randomPartIdx;
+              let j;
+              if (uuidLength === null || typeof uuidLength === "undefined" || uuidLength < 1) {
+                throw new Error("Invalid UUID Length Provided");
+              }
+              const isPositive = uuidLength >= 0;
+              id6 = "";
+              for (j = 0; j < uuidLength; j += 1) {
+                randomPartIdx = parseInt(
+                  (Math.random() * this.dictLength).toFixed(0),
+                  10
+                ) % this.dictLength;
+                id6 += this.dict[randomPartIdx];
+              }
+              return id6;
+            });
+            __publicField(this, "fmt", (format4, date5) => {
+              return this.formattedUUID(format4, date5);
+            });
+            __publicField(this, "formattedUUID", (format4, date5) => {
+              const fnMap = {
+                "$r": this.randomUUID,
+                "$s": this.sequentialUUID,
+                "$t": this.stamp
+              };
+              const result5 = 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" && date5) {
+                    return fnMap[fn2](len, date5);
+                  }
+                  return fnMap[fn2](len);
+                }
+              );
+              return result5;
+            });
+            __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, date5) => {
+              const hexStamp = Math.floor(+(date5 || /* @__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 id6 = this.randomUUID(idLength);
+              return `${id6.substring(0, rndIdx)}${hexStamp}${id6.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;
+            });
+            const options = __spreadValues(__spreadValues({}, DEFAULT_OPTIONS), argOptions);
+            this.counter = 0;
+            this.debug = false;
+            this.dict = [];
+            this.version = version6;
+            const {
+              dictionary,
+              shuffle,
+              length: length2,
+              counter
+            } = options;
+            this.uuidLength = length2;
+            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 __toCommonJS2(src_exports2);
+      })();
+      "undefined" != typeof module3 && (module3.exports = ShortUniqueId2.default), "undefined" != typeof window && (ShortUniqueId2 = ShortUniqueId2.default);
+    }
+  });
+
+  // ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/generate-id.js
+  function generateId() {
+    return uid.rnd(6);
+  }
+  var import_short_unique_id, uid;
+  var init_generate_id = __esm({
+    "../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/generate-id.js"() {
+      import_short_unique_id = __toESM(require_short_unique_id(), 1);
+      uid = new import_short_unique_id.default({ length: 10 });
+    }
+  });
+
   // ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/queries/AddressBookQuery.js
   var AddressBookQuery;
   var init_AddressBookQuery = __esm({
     "../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/queries/AddressBookQuery.js"() {
       init_esm();
       init_namespaces();
-      init_esm_browser();
+      init_generate_id();
       AddressBookQuery = class {
         constructor(store, addressBookNode) {
           this.store = store;
@@ -42525,7 +42797,7 @@ var PodOS = (() => {
           return this.proposeNewNode("Group");
         }
         proposeNewNode(containerPath) {
-          const id6 = v4_default();
+          const id6 = generateId();
           const baseUri = this.addressBookNode.dir()?.uri;
           return namedNode2(`${baseUri}${containerPath}/${id6}/index.ttl#this`);
         }
@@ -42639,7 +42911,7 @@ var PodOS = (() => {
 
   // ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/createAddressBook.js
   function createAddressBook(container2, name7) {
-    const id6 = v4_default();
+    const id6 = generateId();
     const uri6 = `${container2}${id6}/index.ttl#this`;
     const nameEmailIndexUri = `${container2}${id6}/people.ttl`;
     const groupIndexUri = `${container2}${id6}/groups.ttl`;
@@ -42659,8 +42931,8 @@ var PodOS = (() => {
   var init_createAddressBook = __esm({
     "../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/createAddressBook.js"() {
       init_esm();
-      init_esm_browser();
       init_namespaces();
+      init_generate_id();
     }
   });
 
@@ -42831,6 +43103,169 @@ var PodOS = (() => {
     }
   });
 
+  // ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/addNewPhoneNumber.js
+  function addNewPhoneNumber(contactNode, phoneNumber) {
+    const id6 = generateId();
+    const uri6 = `${contactNode.doc().uri}#${id6}`;
+    return {
+      uri: uri6,
+      insertions: [
+        st2(contactNode, vcard("hasTelephone"), namedNode2(uri6), contactNode.doc()),
+        st2(namedNode2(uri6), vcard("value"), namedNode2("tel:" + phoneNumber), contactNode.doc())
+      ],
+      deletions: [],
+      filesToCreate: []
+    };
+  }
+  var init_addNewPhoneNumber = __esm({
+    "../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/addNewPhoneNumber.js"() {
+      init_esm();
+      init_generate_id();
+      init_namespaces();
+    }
+  });
+
+  // ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/addNewEmailAddress.js
+  function addNewEmailAddress(contactNode, emailAddress) {
+    const id6 = generateId();
+    const uri6 = `${contactNode.doc().uri}#${id6}`;
+    return {
+      uri: uri6,
+      insertions: [
+        st2(contactNode, vcard("hasEmail"), namedNode2(uri6), contactNode.doc()),
+        st2(namedNode2(uri6), vcard("value"), namedNode2("mailto:" + emailAddress), contactNode.doc())
+      ],
+      deletions: [],
+      filesToCreate: []
+    };
+  }
+  var init_addNewEmailAddress = __esm({
+    "../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/addNewEmailAddress.js"() {
+      init_esm();
+      init_generate_id();
+      init_namespaces();
+    }
+  });
+
+  // ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/removePhoneNumber.js
+  function removePhoneNumber(contactNode, phoneNode, store) {
+    const phoneStatements = store.statementsMatching(phoneNode, null, null, phoneNode.doc());
+    return {
+      uri: "",
+      insertions: [],
+      deletions: [
+        ...phoneStatements,
+        st2(contactNode, vcard("hasTelephone"), phoneNode, contactNode.doc())
+      ],
+      filesToCreate: []
+    };
+  }
+  var init_removePhoneNumber = __esm({
+    "../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/removePhoneNumber.js"() {
+      init_esm();
+      init_namespaces();
+    }
+  });
+
+  // ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/removeEmailAddress.js
+  function removeEmailAddress(contactNode, emailNode, store) {
+    const emailStatements = store.statementsMatching(emailNode, null, null, emailNode.doc());
+    return {
+      uri: "",
+      insertions: [],
+      deletions: [
+        ...emailStatements,
+        st2(contactNode, vcard("hasEmail"), emailNode, contactNode.doc())
+      ],
+      filesToCreate: []
+    };
+  }
+  var init_removeEmailAddress = __esm({
+    "../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/removeEmailAddress.js"() {
+      init_esm();
+      init_namespaces();
+    }
+  });
+
+  // ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/queries/ProfileQuery.js
+  var ProfileQuery;
+  var init_ProfileQuery = __esm({
+    "../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/queries/ProfileQuery.js"() {
+      init_esm();
+      init_namespaces();
+      ProfileQuery = class {
+        constructor(webIdNode, store) {
+          this.webIdNode = webIdNode;
+          this.store = store;
+        }
+        queryPublicTypeIndex() {
+          const predicate2 = solid("publicTypeIndex");
+          return this.queryNamedNode(predicate2);
+        }
+        queryPreferencesFile() {
+          const predicate2 = pim("preferencesFile");
+          return this.queryNamedNode(predicate2);
+        }
+        queryNamedNode(predicate2) {
+          const node2 = this.store.any(this.webIdNode, predicate2, null, this.webIdNode.doc());
+          if (isNamedNode(node2)) {
+            return node2;
+          }
+          return null;
+        }
+      };
+    }
+  });
+
+  // ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/queries/TypeIndexQuery.js
+  var TypeIndexQuery;
+  var init_TypeIndexQuery = __esm({
+    "../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/queries/TypeIndexQuery.js"() {
+      init_esm();
+      init_namespaces();
+      TypeIndexQuery = class {
+        constructor(store, typeIndexDoc) {
+          this.store = store;
+          this.typeIndexDoc = typeIndexDoc;
+        }
+        queryAddressBookInstances() {
+          const addressBookRegistrations = this.store.each(null, solid("forClass"), vcard("AddressBook"), this.typeIndexDoc);
+          return addressBookRegistrations.flatMap((registration) => {
+            if (!isNamedNode(registration))
+              return [];
+            return this.getInstanceValues(registration);
+          });
+        }
+        getInstanceValues(registration) {
+          return this.store.each(registration, solid("instance"), null, this.typeIndexDoc).map((it) => it.value);
+        }
+      };
+    }
+  });
+
+  // ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/queries/PreferencesQuery.js
+  var PreferencesQuery;
+  var init_PreferencesQuery = __esm({
+    "../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/queries/PreferencesQuery.js"() {
+      init_esm();
+      init_namespaces();
+      PreferencesQuery = class {
+        constructor(store, webIdNode, preferencesDoc) {
+          this.store = store;
+          this.webIdNode = webIdNode;
+          this.preferencesDoc = preferencesDoc;
+        }
+        queryPrivateTypeIndex() {
+          const node2 = this.store.any(this.webIdNode, solid("privateTypeIndex"), null, this.preferencesDoc);
+          if (isNamedNode(node2)) {
+            return node2;
+          }
+          return null;
+        }
+      };
+    }
+  });
+
   // ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/ContactsModuleRdfLib.js
   var ContactsModuleRdfLib;
   var init_ContactsModuleRdfLib = __esm({
@@ -42844,6 +43279,13 @@ var PodOS = (() => {
       init_GroupQuery();
       init_addContactToGroup();
       init_removeContactFromGroup();
+      init_addNewPhoneNumber();
+      init_addNewEmailAddress();
+      init_removePhoneNumber();
+      init_removeEmailAddress();
+      init_ProfileQuery();
+      init_TypeIndexQuery();
+      init_PreferencesQuery();
       ContactsModuleRdfLib = class {
         constructor(config) {
           this.store = config.store;
@@ -42956,6 +43398,65 @@ var PodOS = (() => {
           const operation3 = removeContactFromGroup(contactQuery, groupQuery);
           await executeUpdate(this.fetcher, this.updater, operation3);
         }
+        async addNewPhoneNumber({ contactUri, newPhoneNumber }) {
+          const contactNode = namedNode2(contactUri);
+          const operation3 = addNewPhoneNumber(contactNode, newPhoneNumber);
+          await executeUpdate(this.fetcher, this.updater, operation3);
+          return operation3.uri;
+        }
+        async addNewEmailAddress({ contactUri, newEmailAddress }) {
+          const contactNode = namedNode2(contactUri);
+          const operation3 = addNewEmailAddress(contactNode, newEmailAddress);
+          await executeUpdate(this.fetcher, this.updater, operation3);
+          return operation3.uri;
+        }
+        async removePhoneNumber({ contactUri, phoneNumberUri }) {
+          const contactNode = namedNode2(contactUri);
+          const phoneNumberNode = namedNode2(phoneNumberUri);
+          await this.fetchNode(phoneNumberNode);
+          const operation3 = removePhoneNumber(contactNode, phoneNumberNode, this.store);
+          await executeUpdate(this.fetcher, this.updater, operation3);
+        }
+        async removeEmailAddress({ contactUri, emailAddressUri }) {
+          const contactNode = namedNode2(contactUri);
+          const emailAddressNode = namedNode2(emailAddressUri);
+          await this.fetchNode(emailAddressNode);
+          const operation3 = removeEmailAddress(contactNode, emailAddressNode, this.store);
+          await executeUpdate(this.fetcher, this.updater, operation3);
+        }
+        async listAddressBooks(webId) {
+          const profileNode = namedNode2(webId);
+          await this.fetchNode(profileNode);
+          const profileQuery = new ProfileQuery(profileNode, this.store);
+          const publicTypeIndexNode = profileQuery.queryPublicTypeIndex();
+          const preferencesFile2 = profileQuery.queryPreferencesFile();
+          const promisePublicUris = this.fetchIndexedAddressBooks(publicTypeIndexNode);
+          const promisePrivateTypeIndex = this.fetchPrivateTypeIndex(profileNode, preferencesFile2);
+          const [publicUris, privateTypeIndex2] = await Promise.allSettled([
+            promisePublicUris,
+            promisePrivateTypeIndex
+          ]);
+          const privateUris = privateTypeIndex2.status === "fulfilled" ? await this.fetchIndexedAddressBooks(privateTypeIndex2.value) : [];
+          return {
+            publicUris: publicUris.status === "fulfilled" ? publicUris.value : [],
+            privateUris
+          };
+        }
+        async fetchIndexedAddressBooks(publicTypeIndexNode) {
+          if (!publicTypeIndexNode) {
+            return [];
+          }
+          await this.fetchNode(publicTypeIndexNode);
+          return new TypeIndexQuery(this.store, publicTypeIndexNode).queryAddressBookInstances();
+        }
+        async fetchPrivateTypeIndex(profileNode, preferencesFile2) {
+          if (!preferencesFile2) {
+            return null;
+          }
+          await this.fetchNode(preferencesFile2);
+          const preferencesQuery = new PreferencesQuery(this.store, profileNode, preferencesFile2);
+          return preferencesQuery.queryPrivateTypeIndex();
+        }
       };
     }
   });
@@ -45998,8 +46499,55 @@ var PodOS = (() => {
     return generateKeyPair(alg, options);
   }
 
+  // ../node_modules/uuid/dist/esm-browser/rng.js
+  var getRandomValues;
+  var rnds8 = new Uint8Array(16);
+  function rng() {
+    if (!getRandomValues) {
+      getRandomValues = typeof crypto !== "undefined" && crypto.getRandomValues && crypto.getRandomValues.bind(crypto);
+      if (!getRandomValues) {
+        throw new Error("crypto.getRandomValues() not supported. See https://github.com/uuidjs/uuid#getrandomvalues-not-supported");
+      }
+    }
+    return getRandomValues(rnds8);
+  }
+
+  // ../node_modules/uuid/dist/esm-browser/stringify.js
+  var byteToHex = [];
+  for (let i = 0; i < 256; ++i) {
+    byteToHex.push((i + 256).toString(16).slice(1));
+  }
+  function unsafeStringify(arr, offset3 = 0) {
+    return byteToHex[arr[offset3 + 0]] + byteToHex[arr[offset3 + 1]] + byteToHex[arr[offset3 + 2]] + byteToHex[arr[offset3 + 3]] + "-" + byteToHex[arr[offset3 + 4]] + byteToHex[arr[offset3 + 5]] + "-" + byteToHex[arr[offset3 + 6]] + byteToHex[arr[offset3 + 7]] + "-" + byteToHex[arr[offset3 + 8]] + byteToHex[arr[offset3 + 9]] + "-" + byteToHex[arr[offset3 + 10]] + byteToHex[arr[offset3 + 11]] + byteToHex[arr[offset3 + 12]] + byteToHex[arr[offset3 + 13]] + byteToHex[arr[offset3 + 14]] + byteToHex[arr[offset3 + 15]];
+  }
+
+  // ../node_modules/uuid/dist/esm-browser/native.js
+  var randomUUID = typeof crypto !== "undefined" && crypto.randomUUID && crypto.randomUUID.bind(crypto);
+  var native_default = {
+    randomUUID
+  };
+
+  // ../node_modules/uuid/dist/esm-browser/v4.js
+  function v4(options, buf, offset3) {
+    if (native_default.randomUUID && !buf && !options) {
+      return native_default.randomUUID();
+    }
+    options = options || {};
+    const rnds = options.random || (options.rng || rng)();
+    rnds[6] = rnds[6] & 15 | 64;
+    rnds[8] = rnds[8] & 63 | 128;
+    if (buf) {
+      offset3 = offset3 || 0;
+      for (let i = 0; i < 16; ++i) {
+        buf[offset3 + i] = rnds[i];
+      }
+      return buf;
+    }
+    return unsafeStringify(rnds);
+  }
+  var v4_default = v4;
+
   // ../node_modules/@inrupt/solid-client-authn-core/dist/index.mjs
-  init_esm_browser();
   var SOLID_CLIENT_AUTHN_KEY_PREFIX = "solidClientAuthn:";
   var PREFERRED_SIGNING_ALG = ["ES256", "RS256"];
   var EVENTS = {
@@ -46651,7 +47199,6 @@ var PodOS = (() => {
   }
 
   // ../node_modules/@inrupt/solid-client-authn-browser/dist/index.mjs
-  init_esm_browser();
   var import_events2 = __toESM(require_events(), 1);
 
   // ../node_modules/@inrupt/oidc-client-ext/dist/index.es.js
@@ -47773,9 +48320,9 @@ var PodOS = (() => {
       return this.session.logout();
     }
     trackSession(callback) {
-      this.session.onLogin(() => callback(this.session.info));
-      this.session.onLogout(() => callback(this.session.info));
-      this.session.onSessionRestore(() => callback(this.session.info));
+      this.session.on(EVENTS.LOGIN, () => callback(this.session.info));
+      this.session.on(EVENTS.LOGOUT, () => callback(this.session.info));
+      this.session.on(EVENTS.SESSION_RESTORED, () => callback(this.session.info));
       callback(this.session.info);
     }
   };
@@ -48271,7 +48818,7 @@ var PodOS = (() => {
     sec: () => sec,
     sioc: () => sioc,
     skos: () => skos,
-    solid: () => solid,
+    solid: () => solid2,
     space: () => space,
     tab: () => tab,
     tabont: () => tabont,
@@ -48624,7 +49171,7 @@ var PodOS = (() => {
   var DomainOf_rrule = "http://www.w3.org/2002/12/cal/ical#DomainOf_rrule";
   var relatedTo = "http://www.w3.org/2002/12/cal/ical#relatedTo";
   var url2 = "http://www.w3.org/2002/12/cal/ical#url";
-  var uid = "http://www.w3.org/2002/12/cal/ical#uid";
+  var uid2 = "http://www.w3.org/2002/12/cal/ical#uid";
   var exdate = "http://www.w3.org/2002/12/cal/ical#exdate";
   var exrule = "http://www.w3.org/2002/12/cal/ical#exrule";
   var Value_RECUR = "http://www.w3.org/2002/12/cal/ical#Value_RECUR";
@@ -48684,7 +49231,7 @@ var PodOS = (() => {
     DomainOf_rrule,
     relatedTo,
     url: url2,
-    uid,
+    uid: uid2,
     exdate,
     exrule,
     Value_RECUR,
@@ -51112,7 +51659,7 @@ var PodOS = (() => {
   var _daysSupply = "http://hl7.org/fhir/_daysSupply";
   var reportingVendor = "http://hl7.org/fhir/reportingVendor";
   var current = "http://hl7.org/fhir/current";
-  var uid2 = "http://hl7.org/fhir/uid";
+  var uid3 = "http://hl7.org/fhir/uid";
   var order = "http://hl7.org/fhir/order";
   var priorPrescription = "http://hl7.org/fhir/priorPrescription";
   var distanceFromLandmark = "http://hl7.org/fhir/distanceFromLandmark";
@@ -55345,7 +55892,7 @@ var PodOS = (() => {
     _daysSupply,
     reportingVendor,
     current,
-    uid: uid2,
+    uid: uid3,
     order,
     priorPrescription,
     distanceFromLandmark,
@@ -68521,7 +69068,7 @@ var PodOS = (() => {
   var sec = secImport;
   var sioc = siocImport;
   var skos = skosImport;
-  var solid = solidImport;
+  var solid2 = solidImport;
   var space = spaceImport;
   var tab = tabImport;
   var tabont = tabontImport;
@@ -68622,9 +69169,9 @@ var PodOS = (() => {
       return this.uriService.proposeUriForNewThing(referenceUri, name7);
     }
     trackSession(callback) {
-      return this.session.trackSession((session4) => {
+      return this.session.trackSession((sessionInfo) => {
         this.store.updater.flagAuthorizationMetadata();
-        callback(session4);
+        callback(sessionInfo, this.session.authenticatedFetch);
       });
     }
     /**