profile-pane 3.2.1 → 3.2.2-test.0

package/lib/303.profile-pane.js

@@ -0,0 +1,1362 @@
+"use strict";
+(this["webpackChunkProfilePane"] = this["webpackChunkProfilePane"] || []).push([[303],{
+
+/***/ 8068
+(module) {
+
+
+var ShortUniqueId = (() => {
+  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, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+  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 __export = (target, all) => {
+    for (var name in all)
+      __defProp(target, name, { get: all[name], enumerable: true });
+  };
+  var __copyProps = (to, from, except, desc) => {
+    if (from && typeof from === "object" || typeof from === "function") {
+      for (let key of __getOwnPropNames(from))
+        if (!__hasOwnProp.call(to, key) && key !== except)
+          __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+    }
+    return to;
+  };
+  var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+  var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+
+  // src/index.ts
+  var index_exports = {};
+  __export(index_exports, {
+    DEFAULT_OPTIONS: () => DEFAULT_OPTIONS,
+    DEFAULT_UUID_LENGTH: () => DEFAULT_UUID_LENGTH,
+    default: () => ShortUniqueId
+  });
+
+  // package.json
+  var version = "5.3.2";
+
+  // src/index.ts
+  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
+      });
+      /* tslint:disable consistent-return */
+      __publicField(this, "log", (...args) => {
+        const finalArgs = [...args];
+        finalArgs[0] = "[short-unique-id] ".concat(args[0]);
+        if (this.debug === true) {
+          if (typeof console !== "undefined" && console !== null) {
+            console.log(...finalArgs);
+            return;
+          }
+        }
+      });
+      /* tslint:enable consistent-return */
+      __publicField(this, "_normalizeDictionary", (dictionary, shuffle) => {
+        let finalDict;
+        if (dictionary && Array.isArray(dictionary) && dictionary.length > 1) {
+          finalDict = dictionary;
+        } else {
+          finalDict = [];
+          this.dictIndex = 0;
+          const rangesName = "_".concat(dictionary, "_dict_ranges");
+          const ranges = this._dict_ranges[rangesName];
+          let capacity = 0;
+          for (const [, rangeValue] of Object.entries(ranges)) {
+            const [lower, upper] = rangeValue;
+            capacity += Math.abs(upper - lower);
+          }
+          finalDict = new Array(capacity);
+          let dictIdx = 0;
+          for (const [, rangeTypeValue] of Object.entries(ranges)) {
+            this.dictRange = rangeTypeValue;
+            this.lowerBound = this.dictRange[0];
+            this.upperBound = this.dictRange[1];
+            const isAscending = this.lowerBound <= this.upperBound;
+            const start = this.lowerBound;
+            const end = this.upperBound;
+            if (isAscending) {
+              for (let i = start; i < end; i++) {
+                finalDict[dictIdx++] = String.fromCharCode(i);
+                this.dictIndex = i;
+              }
+            } else {
+              for (let i = start; i > end; i--) {
+                finalDict[dictIdx++] = String.fromCharCode(i);
+                this.dictIndex = i;
+              }
+            }
+          }
+          finalDict.length = dictIdx;
+        }
+        if (shuffle) {
+          const len = finalDict.length;
+          for (let i = len - 1; i > 0; i--) {
+            const j = Math.floor(Math.random() * (i + 1));
+            [finalDict[i], finalDict[j]] = [finalDict[j], finalDict[i]];
+          }
+        }
+        return finalDict;
+      });
+      /** Change the dictionary after initialization. */
+      __publicField(this, "setDictionary", (dictionary, shuffle) => {
+        this.dict = this._normalizeDictionary(dictionary, shuffle);
+        this.dictLength = this.dict.length;
+        this.setCounter(0);
+      });
+      __publicField(this, "seq", () => {
+        return this.sequentialUUID();
+      });
+      /**
+       * Generates UUID based on internal counter that's incremented after each ID generation.
+       * @alias `const uid = new ShortUniqueId(); uid.seq();`
+       */
+      __publicField(this, "sequentialUUID", () => {
+        const dictLen = this.dictLength;
+        const dict = this.dict;
+        let counterDiv = this.counter;
+        const idParts = [];
+        do {
+          const counterRem = counterDiv % dictLen;
+          counterDiv = Math.trunc(counterDiv / dictLen);
+          idParts.push(dict[counterRem]);
+        } while (counterDiv !== 0);
+        const id = idParts.join("");
+        this.counter += 1;
+        return id;
+      });
+      __publicField(this, "rnd", (uuidLength = this.uuidLength || DEFAULT_UUID_LENGTH) => {
+        return this.randomUUID(uuidLength);
+      });
+      /**
+       * Generates UUID by creating each part randomly.
+       * @alias `const uid = new ShortUniqueId(); uid.rnd(uuidLength: number);`
+       */
+      __publicField(this, "randomUUID", (uuidLength = this.uuidLength || DEFAULT_UUID_LENGTH) => {
+        if (uuidLength === null || typeof uuidLength === "undefined" || uuidLength < 1) {
+          throw new Error("Invalid UUID Length Provided");
+        }
+        const result = new Array(uuidLength);
+        const dictLen = this.dictLength;
+        const dict = this.dict;
+        for (let j = 0; j < uuidLength; j++) {
+          const randomPartIdx = Math.floor(Math.random() * dictLen);
+          result[j] = dict[randomPartIdx];
+        }
+        return result.join("");
+      });
+      __publicField(this, "fmt", (format, date) => {
+        return this.formattedUUID(format, date);
+      });
+      /**
+       * Generates custom UUID with the provided format string.
+       * @alias `const uid = new ShortUniqueId(); uid.fmt(format: string);`
+       */
+      __publicField(this, "formattedUUID", (format, date) => {
+        const fnMap = {
+          $r: this.randomUUID,
+          $s: this.sequentialUUID,
+          $t: this.stamp
+        };
+        const result = format.replace(/\$[rs]\d{0,}|\$t0|\$t[1-9]\d{1,}/g, (m) => {
+          const fn = m.slice(0, 2);
+          const len = Number.parseInt(m.slice(2), 10);
+          if (fn === "$s") {
+            return fnMap[fn]().padStart(len, "0");
+          }
+          if (fn === "$t" && date) {
+            return fnMap[fn](len, date);
+          }
+          return fnMap[fn](len);
+        });
+        return result;
+      });
+      /**
+       * Calculates total number of possible UUIDs.
+       *
+       * Given that:
+       *
+       * - `H` is the total number of possible UUIDs
+       * - `n` is the number of unique characters in the dictionary
+       * - `l` is the UUID length
+       *
+       * Then `H` is defined as `n` to the power of `l`:
+       *
+       * <div style="background: white; padding: 5px; border-radius: 5px; overflow: hidden;">
+       *  <img src="data:image/png;base64,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" />
+       * </div>
+       *
+       * This function returns `H`.
+       */
+      __publicField(this, "availableUUIDs", (uuidLength = this.uuidLength) => {
+        return Number.parseFloat(([...new Set(this.dict)].length ** uuidLength).toFixed(0));
+      });
+      /**
+       * Calculates approximate number of hashes before first collision.
+       *
+       * Given that:
+       *
+       * - `H` is the total number of possible UUIDs, or in terms of this library,
+       * the result of running `availableUUIDs()`
+       * - the expected number of values we have to choose before finding the
+       * first collision can be expressed as the quantity `Q(H)`
+       *
+       * Then `Q(H)` can be approximated as the square root of the product of half
+       * of pi times `H`:
+       *
+       * <div style="background: white; padding: 5px; border-radius: 5px; overflow: hidden;">
+       *  <img src="data:image/png;base64,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" />
+       * </div>
+       *
+       * This function returns `Q(H)`.
+       *
+       * (see [Poisson distribution](https://en.wikipedia.org/wiki/Poisson_distribution))
+       */
+      // Cache for memoization
+      __publicField(this, "_collisionCache", /* @__PURE__ */ new Map());
+      __publicField(this, "approxMaxBeforeCollision", (rounds = this.availableUUIDs(this.uuidLength)) => {
+        const cacheKey = rounds;
+        const cached = this._collisionCache.get(cacheKey);
+        if (cached !== void 0) {
+          return cached;
+        }
+        const result = Number.parseFloat(Math.sqrt(Math.PI / 2 * rounds).toFixed(20));
+        this._collisionCache.set(cacheKey, result);
+        return result;
+      });
+      /**
+       * Calculates probability of generating duplicate UUIDs (a collision) in a
+       * given number of UUID generation rounds.
+       *
+       * Given that:
+       *
+       * - `r` is the maximum number of times that `randomUUID()` will be called,
+       * or better said the number of _rounds_
+       * - `H` is the total number of possible UUIDs, or in terms of this library,
+       * the result of running `availableUUIDs()`
+       *
+       * Then the probability of collision `p(r; H)` can be approximated as the result
+       * of dividing the square root of the product of half of pi times `r` by `H`:
+       *
+       * <div style="background: white; padding: 5px; border-radius: 5px; overflow: hidden;">
+       *  <img src="data:image/png;base64,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" />
+       * </div>
+       *
+       * This function returns `p(r; H)`.
+       *
+       * (see [Poisson distribution](https://en.wikipedia.org/wiki/Poisson_distribution))
+       *
+       * (Useful if you are wondering _"If I use this lib and expect to perform at most
+       * `r` rounds of UUID generations, what is the probability that I will hit a duplicate UUID?"_.)
+       */
+      __publicField(this, "collisionProbability", (rounds = this.availableUUIDs(this.uuidLength), uuidLength = this.uuidLength) => {
+        return Number.parseFloat(
+          (this.approxMaxBeforeCollision(rounds) / this.availableUUIDs(uuidLength)).toFixed(20)
+        );
+      });
+      /**
+       * Calculate a "uniqueness" score (from 0 to 1) of UUIDs based on size of
+       * dictionary and chosen UUID length.
+       *
+       * Given that:
+       *
+       * - `H` is the total number of possible UUIDs, or in terms of this library,
+       * the result of running `availableUUIDs()`
+       * - `Q(H)` is the approximate number of hashes before first collision,
+       * or in terms of this library, the result of running `approxMaxBeforeCollision()`
+       *
+       * Then `uniqueness` can be expressed as the additive inverse of the probability of
+       * generating a "word" I had previously generated (a duplicate) at any given iteration
+       * up to the the total number of possible UUIDs expressed as the quotiend of `Q(H)` and `H`:
+       *
+       * <div style="background: white; padding: 5px; border-radius: 5px; overflow: hidden;">
+       *  <img src="data:image/png;base64,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" />
+       * </div>
+       *
+       * (Useful if you need a value to rate the "quality" of the combination of given dictionary
+       * and UUID length. The closer to 1, higher the uniqueness and thus better the quality.)
+       */
+      __publicField(this, "uniqueness", (rounds = this.availableUUIDs(this.uuidLength)) => {
+        const score = Number.parseFloat(
+          (1 - this.approxMaxBeforeCollision(rounds) / rounds).toFixed(20)
+        );
+        return score > 1 ? 1 : score < 0 ? 0 : score;
+      });
+      /**
+       * Return the version of this module.
+       */
+      __publicField(this, "getVersion", () => {
+        return this.version;
+      });
+      /**
+       * Generates a UUID with a timestamp that can be extracted using `uid.parseStamp(stampString);`.
+       *
+       * ```js
+       *  const uidWithTimestamp = uid.stamp(32);
+       *  console.log(uidWithTimestamp);
+       *  // GDa608f973aRCHLXQYPTbKDbjDeVsSb3
+       *
+       *  console.log(uid.parseStamp(uidWithTimestamp));
+       *  // 2021-05-03T06:24:58.000Z
+       *  ```
+       */
+      __publicField(this, "stamp", (finalLength, date) => {
+        const hexStamp = Math.floor(+(date || /* @__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 id = this.randomUUID(idLength);
+        return "".concat(id.substring(0, rndIdx)).concat(hexStamp).concat(id.substring(rndIdx)).concat(rndIdx.toString(16));
+      });
+      /**
+       * Extracts the date embeded in a UUID generated using the `uid.stamp(finalLength);` method.
+       *
+       * ```js
+       *  const uidWithTimestamp = uid.stamp(32);
+       *  console.log(uidWithTimestamp);
+       *  // GDa608f973aRCHLXQYPTbKDbjDeVsSb3
+       *
+       *  console.log(uid.parseStamp(uidWithTimestamp));
+       *  // 2021-05-03T06:24:58.000Z
+       *  ```
+       */
+      __publicField(this, "parseStamp", (suid, format) => {
+        if (format && !/t0|t[1-9]\d{1,}/.test(format)) {
+          throw new Error("Cannot extract date from a formated UUID with no timestamp in the format");
+        }
+        const stamp = format ? format.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 fn = m.slice(0, 2);
+          const len = Number.parseInt(m.slice(2), 10);
+          return fnMap[fn](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(Number.parseInt(stamp, 16) * 1e3);
+        }
+        if (stamp.length < 10) {
+          throw new Error("Stamp length invalid");
+        }
+        const rndIdx = Number.parseInt(stamp.substring(stamp.length - 1), 16);
+        return new Date(Number.parseInt(stamp.substring(rndIdx, rndIdx + 8), 16) * 1e3);
+      });
+      /**
+       * Set the counter to a specific value.
+       */
+      __publicField(this, "setCounter", (counter) => {
+        this.counter = counter;
+      });
+      /**
+       * Validate given UID contains only characters from the instanced dictionary or optionally provided dictionary.
+       */
+      __publicField(this, "validate", (uid, dictionary) => {
+        const finalDictionary = dictionary ? this._normalizeDictionary(dictionary) : this.dict;
+        return uid.split("").every((c) => finalDictionary.includes(c));
+      });
+      const options = __spreadValues(__spreadValues({}, DEFAULT_OPTIONS), argOptions);
+      this.counter = 0;
+      this.debug = false;
+      this.dict = [];
+      this.version = version;
+      const { dictionary, shuffle, length, counter } = options;
+      this.uuidLength = length;
+      this.setDictionary(dictionary, shuffle);
+      this.setCounter(counter);
+      this.debug = options.debug;
+      this.log(this.dict);
+      this.log(
+        "Generator instantiated with Dictionary Size ".concat(this.dictLength, " and counter set to ").concat(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);
+    }
+  };
+  /** @hidden */
+  __publicField(_ShortUniqueId, "default", _ShortUniqueId);
+  var ShortUniqueId = _ShortUniqueId;
+  return __toCommonJS(index_exports);
+})();
+//# sourceMappingURL=short-unique-id.js.map
+ true&&(module.exports=ShortUniqueId.default),'undefined'!=typeof window&&(ShortUniqueId=ShortUniqueId.default);
+
+/***/ },
+
+/***/ 303
+(__unused_webpack___webpack_module__, __webpack_exports__, __webpack_require__) {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  "default": () => (/* binding */ dist)
+});
+
+// EXTERNAL MODULE: external "rdflib"
+var external_rdflib_ = __webpack_require__(5491);
+;// ./node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/namespaces.js
+
+const vcard = (0,external_rdflib_.Namespace)("http://www.w3.org/2006/vcard/ns#");
+const dc = (0,external_rdflib_.Namespace)("http://purl.org/dc/elements/1.1/");
+//# sourceMappingURL=namespaces.js.map
+// EXTERNAL MODULE: ./node_modules/short-unique-id/dist/short-unique-id.js
+var short_unique_id = __webpack_require__(8068);
+;// ./node_modules/@solid-data-modules/rdflib-utils/dist/identifier/generate-id.js
+
+const uid = new short_unique_id({ length: 10 });
+/**
+ * Generates a short ID that can be used for URI fragments, document or container names.
+ */
+function generateId() {
+    return uid.rnd(6);
+}
+//# sourceMappingURL=generate-id.js.map
+;// ./node_modules/@solid-data-modules/rdflib-utils/dist/identifier/index.js
+
+//# sourceMappingURL=index.js.map
+;// ./node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/queries/AddressBookQuery.js
+
+
+
+class AddressBookQuery {
+    constructor(store, addressBookNode) {
+        this.store = store;
+        this.addressBookNode = addressBookNode;
+        this.addressBookDoc = addressBookNode.doc();
+    }
+    proposeNewContactNode() {
+        return this.proposeNewNode("Person");
+    }
+    proposeNewGroupNode() {
+        return this.proposeNewNode("Group");
+    }
+    proposeNewNode(containerPath) {
+        const id = generateId();
+        const baseUri = this.addressBookNode.dir()?.uri;
+        return (0,external_rdflib_.sym)(`${baseUri}${containerPath}/${id}/index.ttl#this`);
+    }
+    queryTitle() {
+        return (this.store.anyValue(this.addressBookNode, dc("title"), undefined, this.addressBookDoc) ?? "");
+    }
+    queryNameEmailIndex() {
+        const index = this.store.any(this.addressBookNode, vcard("nameEmailIndex"), undefined, this.addressBookDoc);
+        if ((0,external_rdflib_.isNamedNode)(index)) {
+            return index;
+        }
+        else {
+            return null;
+        }
+    }
+    queryContacts() {
+        const nameEmailIndex = this.queryNameEmailIndex();
+        return nameEmailIndex && (0,external_rdflib_.isNamedNode)(nameEmailIndex)
+            ? this.store
+                .each(null, vcard("inAddressBook"), this.addressBookNode, nameEmailIndex)
+                .filter((it) => (0,external_rdflib_.isNamedNode)(it))
+                .map((node) => ({
+                name: this.store.anyValue(node, vcard("fn"), null, nameEmailIndex) ??
+                    "",
+                uri: node.value,
+            }))
+            : [];
+    }
+    queryGroupIndex() {
+        const index = this.store.any(this.addressBookNode, vcard("groupIndex"), undefined, this.addressBookDoc);
+        if ((0,external_rdflib_.isNamedNode)(index)) {
+            return index;
+        }
+        else {
+            return null;
+        }
+    }
+    queryGroups() {
+        const groupIndex = this.queryGroupIndex(); //?
+        return groupIndex && (0,external_rdflib_.isNamedNode)(groupIndex)
+            ? this.store
+                .each(this.addressBookNode, vcard("includesGroup"), null, groupIndex)
+                .filter((it) => (0,external_rdflib_.isNamedNode)(it))
+                .map((node) => ({
+                name: this.store.anyValue(node, vcard("fn"), null, groupIndex) ?? "",
+                uri: node.value,
+            }))
+            : [];
+    }
+}
+//# sourceMappingURL=AddressBookQuery.js.map
+;// ./node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/queries/ContactQuery.js
+
+
+const MAILTO_URI_SCHEME = "mailto:";
+const TEl_URI_SCHEME = "tel:";
+class ContactQuery {
+    constructor(store, contactNode) {
+        this.store = store;
+        this.contactNode = contactNode;
+        this.contactDoc = contactNode.doc();
+    }
+    queryName() {
+        return (this.store.anyValue(this.contactNode, vcard("fn"), undefined, this.contactDoc) ?? "");
+    }
+    queryEmails() {
+        const uris = this.getValuesOf(vcard("hasEmail"));
+        if (uris.length === 0) {
+            return [];
+        }
+        return uris
+            .map((uri) => {
+            const valueNode = this.getValueNode(uri);
+            if (isMailtoNode(valueNode)) {
+                return {
+                    uri,
+                    value: valueNode.value.split(MAILTO_URI_SCHEME)[1],
+                };
+            }
+        })
+            .filter((value) => !!value);
+    }
+    queryPhoneNumbers() {
+        const uris = this.getValuesOf(vcard("hasTelephone"));
+        if (uris.length === 0) {
+            return [];
+        }
+        return uris
+            .map((uri) => {
+            const valueNode = this.getValueNode(uri);
+            if (isTelNode(valueNode)) {
+                return {
+                    uri,
+                    value: valueNode.value.split(TEl_URI_SCHEME)[1],
+                };
+            }
+        })
+            .filter((value) => !!value);
+    }
+    getValuesOf(predicate) {
+        return this.store
+            .statementsMatching(this.contactNode, predicate, undefined, this.contactDoc)
+            .map((it) => it.object.value);
+    }
+    getValueNode(uri) {
+        return this.store.any((0,external_rdflib_.sym)(uri), vcard("value"), undefined, this.contactDoc);
+    }
+}
+function isMailtoNode(valueNode) {
+    return ((0,external_rdflib_.isNamedNode)(valueNode) && valueNode.value.startsWith(MAILTO_URI_SCHEME));
+}
+function isTelNode(valueNode) {
+    return (0,external_rdflib_.isNamedNode)(valueNode) && valueNode.value.startsWith(TEl_URI_SCHEME);
+}
+//# sourceMappingURL=ContactQuery.js.map
+;// ./node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/queries/GroupQuery.js
+
+
+class GroupQuery {
+    constructor(store, groupNode) {
+        this.store = store;
+        this.groupNode = groupNode;
+        this.groupDoc = groupNode.doc();
+    }
+    queryName() {
+        return (this.store.anyValue(this.groupNode, vcard("fn"), undefined, this.groupDoc) ?? "");
+    }
+    queryMembers() {
+        return this.store
+            .each(this.groupNode, vcard("hasMember"), null, this.groupDoc)
+            .filter((it) => (0,external_rdflib_.isNamedNode)(it))
+            .map((node) => ({
+            uri: node.value,
+            name: this.store.anyValue(node, vcard("fn"), null, this.groupDoc) ?? "",
+        }));
+    }
+}
+//# sourceMappingURL=GroupQuery.js.map
+;// ./node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/queries/index.js
+
+
+
+//# sourceMappingURL=index.js.map
+;// ./node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/createAddressBook.js
+
+
+
+function createAddressBook(container, name) {
+    const id = generateId();
+    const uri = `${container}${id}/index.ttl#this`;
+    const nameEmailIndexUri = `${container}${id}/people.ttl`;
+    const groupIndexUri = `${container}${id}/groups.ttl`;
+    const insertions = [
+        (0,external_rdflib_.st)((0,external_rdflib_.sym)(uri), (0,external_rdflib_.sym)("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"), vcard("AddressBook"), (0,external_rdflib_.sym)(uri).doc()),
+        (0,external_rdflib_.st)((0,external_rdflib_.sym)(uri), dc("title"), (0,external_rdflib_.lit)(name), (0,external_rdflib_.sym)(uri).doc()),
+        (0,external_rdflib_.st)((0,external_rdflib_.sym)(uri), vcard("nameEmailIndex"), (0,external_rdflib_.sym)(nameEmailIndexUri), (0,external_rdflib_.sym)(uri).doc()),
+        (0,external_rdflib_.st)((0,external_rdflib_.sym)(uri), vcard("groupIndex"), (0,external_rdflib_.sym)(groupIndexUri), (0,external_rdflib_.sym)(uri).doc()),
+    ];
+    return {
+        uri,
+        deletions: [],
+        insertions,
+        filesToCreate: [{ url: nameEmailIndexUri }, { url: groupIndexUri }],
+    };
+}
+//# sourceMappingURL=createAddressBook.js.map
+;// ./node_modules/@solid-data-modules/rdflib-utils/dist/web-operations/executeUpdate.js
+/**
+ * Applies the described updates to a Pod
+ * @param fetcher - The fetcher to use for the update
+ * @param updater - The updater to use for the update
+ * @param operation - The operations to perform
+ */
+async function executeUpdate(fetcher, updater, operation) {
+    await updater.updateMany(operation.deletions, operation.insertions);
+    operation.filesToCreate.map((file) => {
+        createEmptyTurtleFile(fetcher, file.url);
+    });
+}
+function createEmptyTurtleFile(fetcher, url) {
+    return fetcher.webOperation("PUT", url, {
+        contentType: "text/turtle",
+    });
+}
+//# sourceMappingURL=executeUpdate.js.map
+;// ./node_modules/@solid-data-modules/rdflib-utils/dist/web-operations/fetchNode.js
+/**
+ * Nullsafe fetching of a node
+ * @param fetcher - The fetcher to use
+ * @param node - A node to fetch, or null to do nothing at all
+ */
+async function fetchNode(fetcher, node) {
+    if (node) {
+        await fetcher.load(node.value);
+    }
+}
+//# sourceMappingURL=fetchNode.js.map
+;// ./node_modules/@solid-data-modules/rdflib-utils/dist/web-operations/index.js
+
+
+//# sourceMappingURL=index.js.map
+;// ./node_modules/@solid-data-modules/rdflib-utils/dist/namespaces/index.js
+
+const rdf = (0,external_rdflib_.Namespace)("http://www.w3.org/1999/02/22-rdf-syntax-ns#");
+const solid = (0,external_rdflib_.Namespace)("http://www.w3.org/ns/solid/terms#");
+const pim = (0,external_rdflib_.Namespace)("http://www.w3.org/ns/pim/space#");
+const ldp = (0,external_rdflib_.Namespace)("http://www.w3.org/ns/ldp#");
+//# sourceMappingURL=index.js.map
+;// ./node_modules/@solid-data-modules/rdflib-utils/dist/queries/PreferencesQuery.js
+
+
+/**
+ * Used query data from a user's preferences file
+ */
+class PreferencesQuery {
+    constructor(store, 
+    /**
+     * The WebID of the user
+     */
+    webIdNode, 
+    /**
+     * The preferences file
+     */
+    preferencesDoc) {
+        this.store = store;
+        this.webIdNode = webIdNode;
+        this.preferencesDoc = preferencesDoc;
+    }
+    /**
+     * Look up the private type index. Returns null if none is found or if the predicated does not link to a proper named node
+     */
+    queryPrivateTypeIndex() {
+        const node = this.store.any(this.webIdNode, solid("privateTypeIndex"), null, this.preferencesDoc);
+        if ((0,external_rdflib_.isNamedNode)(node)) {
+            return node;
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=PreferencesQuery.js.map
+;// ./node_modules/@solid-data-modules/rdflib-utils/dist/queries/ProfileQuery.js
+
+
+/**
+ * Used query data from a user's profile document
+ */
+class ProfileQuery {
+    constructor(
+    /**
+     * The WebID of the user
+     */
+    webIdNode, store) {
+        this.webIdNode = webIdNode;
+        this.store = store;
+    }
+    /**
+     * Look up the public type index. Returns null if none is found or if the predicated does not link to a proper named node
+     */
+    queryPublicTypeIndex() {
+        const predicate = solid("publicTypeIndex");
+        return this.queryNamedNode(predicate);
+    }
+    /**
+     * Look up the preferences file. Returns null if none is found or if the predicated does not link to a proper named node
+     */
+    queryPreferencesFile() {
+        const predicate = pim("preferencesFile");
+        return this.queryNamedNode(predicate);
+    }
+    queryNamedNode(predicate) {
+        const node = this.store.any(this.webIdNode, predicate, null, this.webIdNode.doc());
+        if ((0,external_rdflib_.isNamedNode)(node)) {
+            return node;
+        }
+        return null;
+    }
+}
+//# sourceMappingURL=ProfileQuery.js.map
+;// ./node_modules/@solid-data-modules/rdflib-utils/dist/queries/TypeIndexQuery.js
+
+
+/**
+ * Used query data from a type index document
+ */
+class TypeIndexQuery {
+    constructor(store, typeIndexDoc) {
+        this.store = store;
+        this.typeIndexDoc = typeIndexDoc;
+    }
+    /**
+     * Look up the instances in the type registration for the given RDF class
+     * @param type - The RDF class to look up
+     * @returns A list of the URIs of the found instances
+     */
+    queryInstancesForClass(type) {
+        const registrations = this.store.each(null, solid("forClass"), type, this.typeIndexDoc);
+        return registrations.flatMap((registration) => {
+            if (!(0,external_rdflib_.isNamedNode)(registration))
+                return [];
+            return this.getInstanceValues(registration);
+        });
+    }
+    getInstanceValues(registration) {
+        return this.store
+            .each(registration, solid("instance"), null, this.typeIndexDoc)
+            .map((it) => it.value);
+    }
+}
+//# sourceMappingURL=TypeIndexQuery.js.map
+;// ./node_modules/@solid-data-modules/rdflib-utils/dist/queries/index.js
+
+
+
+//# sourceMappingURL=index.js.map
+;// ./node_modules/@solid-data-modules/rdflib-utils/dist/module/ModuleSupport.js
+
+
+
+/**
+ * Provides common functionality useful for many rdflib-based data modules
+ */
+class ModuleSupport {
+    constructor(config) {
+        this.store = config.store;
+        this.fetcher = config.fetcher;
+        this.updater = config.updater;
+    }
+    /**
+     * Nullsafe fetching of a node
+     * @param node - A node to fetch, or null to do nothing at all
+     */
+    async fetchNode(node) {
+        return fetchNode(this.fetcher, node);
+    }
+    /**
+     * Fetch all the given nodes in parallel
+     * @param nodes
+     */
+    async fetchAll(nodes) {
+        return Promise.all(nodes.map((it) => this.fetchNode(it)));
+    }
+    /**
+     * Checks whether the resource identified by the given URL is a LDP container
+     * @param storageUrl - The URL to check
+     * @returns true if it is a container, false otherwise
+     */
+    async isContainer(storageUrl) {
+        const storageNode = (0,external_rdflib_.sym)(storageUrl);
+        await this.fetcher.load(storageNode.value);
+        return this.store.holds(storageNode, rdf("type"), ldp("Container"), storageNode.doc());
+    }
+}
+//# sourceMappingURL=ModuleSupport.js.map
+;// ./node_modules/@solid-data-modules/rdflib-utils/dist/module/index.js
+
+//# sourceMappingURL=index.js.map
+;// ./node_modules/@solid-data-modules/rdflib-utils/dist/update-operations/addInstanceToTypeIndex.js
+
+
+
+/**
+ * Create a new type registration for the given type that links to the given resource instance
+ * @param typeIndexDoc - The type index document (private or public)
+ * @param instanceUri - The URI of the instance to add
+ * @param type - The RDF class to register the instance for
+ */
+function addInstanceToTypeIndex(typeIndexDoc, instanceUri, type) {
+    const registrationNode = (0,external_rdflib_.sym)(`${typeIndexDoc.value}#${generateId()}`);
+    return {
+        deletions: [],
+        filesToCreate: [],
+        insertions: [
+            (0,external_rdflib_.st)(registrationNode, rdf("type"), solid("TypeRegistration"), typeIndexDoc),
+            (0,external_rdflib_.st)(registrationNode, solid("forClass"), type, typeIndexDoc),
+            (0,external_rdflib_.st)(registrationNode, solid("instance"), (0,external_rdflib_.sym)(instanceUri), typeIndexDoc),
+        ],
+    };
+}
+//# sourceMappingURL=addInstanceToTypeIndex.js.map
+;// ./node_modules/@solid-data-modules/rdflib-utils/dist/update-operations/index.js
+
+//# sourceMappingURL=index.js.map
+;// ./node_modules/@solid-data-modules/rdflib-utils/dist/index.js
+
+
+
+
+
+//# sourceMappingURL=index.js.map
+;// ./node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/createNewContact.js
+
+
+
+function createNewContact(addressBook, newContact) {
+    const contactNode = addressBook.proposeNewContactNode();
+    const nameEmailIndex = addressBook.queryNameEmailIndex();
+    if (!nameEmailIndex) {
+        throw new Error("name-email index is missing or invalid");
+    }
+    const insertions = [
+        (0,external_rdflib_.st)(contactNode, vcard("inAddressBook"), addressBook.addressBookNode, nameEmailIndex),
+        (0,external_rdflib_.st)(contactNode, vcard("fn"), (0,external_rdflib_.lit)(newContact.name), nameEmailIndex),
+        (0,external_rdflib_.st)(contactNode, vcard("fn"), (0,external_rdflib_.lit)(newContact.name), contactNode.doc()),
+        (0,external_rdflib_.st)(contactNode, rdf("type"), vcard("Individual"), contactNode.doc()),
+    ];
+    if (newContact.email) {
+        const emailNode = (0,external_rdflib_.sym)(contactNode.doc().uri + "#email");
+        insertions.push((0,external_rdflib_.st)(contactNode, vcard("hasEmail"), emailNode, contactNode.doc()), (0,external_rdflib_.st)(emailNode, vcard("value"), (0,external_rdflib_.sym)("mailto:" + newContact.email), contactNode.doc()));
+    }
+    if (newContact.phoneNumber) {
+        const phoneNode = (0,external_rdflib_.sym)(contactNode.doc().uri + "#phone");
+        insertions.push((0,external_rdflib_.st)(contactNode, vcard("hasTelephone"), phoneNode, contactNode.doc()), (0,external_rdflib_.st)(phoneNode, vcard("value"), (0,external_rdflib_.sym)("tel:" + newContact.phoneNumber), contactNode.doc()));
+    }
+    return {
+        uri: contactNode.uri,
+        deletions: [],
+        insertions: insertions,
+        filesToCreate: [],
+    };
+}
+//# sourceMappingURL=createNewContact.js.map
+;// ./node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/createNewGroup.js
+
+
+
+function createNewGroup(addressBook, groupName) {
+    const groupIndex = addressBook.queryGroupIndex();
+    if (!groupIndex) {
+        throw new Error("group index is missing or invalid");
+    }
+    const groupNode = addressBook.proposeNewGroupNode();
+    const groupDoc = groupNode.doc();
+    return {
+        uri: groupNode.uri,
+        insertions: [
+            (0,external_rdflib_.st)(groupNode, vcard("fn"), (0,external_rdflib_.lit)(groupName), groupIndex),
+            (0,external_rdflib_.st)(groupNode, vcard("fn"), (0,external_rdflib_.lit)(groupName), groupDoc),
+            (0,external_rdflib_.st)(groupNode, rdf("type"), vcard("Group"), groupDoc),
+            (0,external_rdflib_.st)(addressBook.addressBookNode, vcard("includesGroup"), groupNode, groupIndex),
+        ],
+        deletions: [],
+        filesToCreate: [],
+    };
+}
+//# sourceMappingURL=createNewGroup.js.map
+;// ./node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/addContactToGroup.js
+
+
+function addContactToGroup(contactQuery, groupQuery) {
+    const name = contactQuery.queryName();
+    return {
+        insertions: [
+            (0,external_rdflib_.st)(groupQuery.groupNode, vcard("hasMember"), contactQuery.contactNode, groupQuery.groupNode.doc()),
+            (0,external_rdflib_.st)(contactQuery.contactNode, vcard("fn"), (0,external_rdflib_.lit)(name), groupQuery.groupNode.doc()),
+        ],
+        deletions: [],
+        filesToCreate: [],
+    };
+}
+//# sourceMappingURL=addContactToGroup.js.map
+;// ./node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/addNewEmailAddress.js
+
+
+
+function addNewEmailAddress(contactNode, emailAddress) {
+    const id = generateId();
+    const uri = `${contactNode.doc().uri}#${id}`;
+    return {
+        uri,
+        insertions: [
+            (0,external_rdflib_.st)(contactNode, vcard("hasEmail"), (0,external_rdflib_.sym)(uri), contactNode.doc()),
+            (0,external_rdflib_.st)((0,external_rdflib_.sym)(uri), vcard("value"), (0,external_rdflib_.sym)("mailto:" + emailAddress), contactNode.doc()),
+        ],
+        deletions: [],
+        filesToCreate: [],
+    };
+}
+//# sourceMappingURL=addNewEmailAddress.js.map
+;// ./node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/addNewPhoneNumber.js
+
+
+
+function addNewPhoneNumber(contactNode, phoneNumber) {
+    const id = generateId();
+    const uri = `${contactNode.doc().uri}#${id}`;
+    return {
+        uri,
+        insertions: [
+            (0,external_rdflib_.st)(contactNode, vcard("hasTelephone"), (0,external_rdflib_.sym)(uri), contactNode.doc()),
+            (0,external_rdflib_.st)((0,external_rdflib_.sym)(uri), vcard("value"), (0,external_rdflib_.sym)("tel:" + phoneNumber), contactNode.doc()),
+        ],
+        deletions: [],
+        filesToCreate: [],
+    };
+}
+//# sourceMappingURL=addNewPhoneNumber.js.map
+;// ./node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/removeContactFromGroup.js
+
+
+function removeContactFromGroup(contactQuery, groupQuery) {
+    const contactUri = contactQuery.contactNode.uri;
+    const member = groupQuery.queryMembers().find((it) => it.uri === contactUri);
+    if (!member) {
+        throw new Error("member not found in group");
+    }
+    return {
+        insertions: [],
+        deletions: [
+            (0,external_rdflib_.st)(groupQuery.groupNode, vcard("hasMember"), contactQuery.contactNode, groupQuery.groupNode.doc()),
+            (0,external_rdflib_.st)(contactQuery.contactNode, vcard("fn"), (0,external_rdflib_.lit)(member.name), groupQuery.groupNode.doc()),
+        ],
+        filesToCreate: [],
+    };
+}
+//# sourceMappingURL=removeContactFromGroup.js.map
+;// ./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 {
+        insertions: [],
+        deletions: [
+            ...emailStatements,
+            (0,external_rdflib_.st)(contactNode, vcard("hasEmail"), emailNode, contactNode.doc()),
+        ],
+        filesToCreate: [],
+    };
+}
+//# sourceMappingURL=removeEmailAddress.js.map
+;// ./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 {
+        insertions: [],
+        deletions: [
+            ...phoneStatements,
+            (0,external_rdflib_.st)(contactNode, vcard("hasTelephone"), phoneNode, contactNode.doc()),
+        ],
+        filesToCreate: [],
+    };
+}
+//# sourceMappingURL=removePhoneNumber.js.map
+;// ./node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/renameContact.js
+
+
+function renameContact(store, contactNode, newName) {
+    const deletions = store.statementsMatching(contactNode, vcard("fn"), null, null);
+    const insertions = deletions.map((it) => (0,external_rdflib_.st)(it.subject, it.predicate, (0,external_rdflib_.lit)(newName), it.graph));
+    return {
+        insertions,
+        deletions,
+        filesToCreate: [],
+    };
+}
+//# sourceMappingURL=renameContact.js.map
+;// ./node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/updateEmailAddress.js
+
+
+function updateEmailAddress(emailAddressNode, newEmailAddress, store) {
+    const oldValue = store.any(emailAddressNode, vcard("value"));
+    const deletions = oldValue
+        ? [(0,external_rdflib_.st)(emailAddressNode, vcard("value"), oldValue, emailAddressNode.doc())]
+        : [];
+    const insertions = [
+        (0,external_rdflib_.st)(emailAddressNode, vcard("value"), (0,external_rdflib_.sym)("mailto:" + newEmailAddress), emailAddressNode.doc()),
+    ];
+    return {
+        insertions,
+        deletions,
+        filesToCreate: [],
+    };
+}
+//# sourceMappingURL=updateEmailAddress.js.map
+;// ./node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/updatePhoneNumber.js
+
+
+function updatePhoneNumber(phoneNumberNode, newPhoneNumber, store) {
+    const oldValue = store.any(phoneNumberNode, vcard("value"));
+    const deletions = oldValue
+        ? [(0,external_rdflib_.st)(phoneNumberNode, vcard("value"), oldValue, phoneNumberNode.doc())]
+        : [];
+    const insertions = [
+        (0,external_rdflib_.st)(phoneNumberNode, vcard("value"), (0,external_rdflib_.sym)("tel:" + newPhoneNumber), phoneNumberNode.doc()),
+    ];
+    return {
+        insertions,
+        deletions,
+        filesToCreate: [],
+    };
+}
+//# sourceMappingURL=updatePhoneNumber.js.map
+;// ./node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/index.js
+
+
+
+
+
+
+
+
+
+
+
+
+//# sourceMappingURL=index.js.map
+;// ./node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/ContactsModuleRdfLib.js
+
+
+
+
+
+const VCARD_ADDRESS_BOOK = vcard("AddressBook");
+class ContactsModuleRdfLib {
+    constructor(config) {
+        this.support = new ModuleSupport(config);
+        this.store = config.store;
+        this.fetcher = config.fetcher;
+        this.updater = config.updater;
+    }
+    async readAddressBook(uri) {
+        const addressBookNode = (0,external_rdflib_.sym)(uri);
+        await this.support.fetchNode(addressBookNode);
+        const query = new AddressBookQuery(this.store, addressBookNode);
+        const title = query.queryTitle();
+        const nameEmailIndex = query.queryNameEmailIndex();
+        const groupIndex = query.queryGroupIndex();
+        await this.support.fetchAll([nameEmailIndex, groupIndex]);
+        const contacts = query.queryContacts();
+        const groups = query.queryGroups();
+        return {
+            uri,
+            title,
+            contacts,
+            groups,
+        };
+    }
+    async createAddressBook({ containerUri, name, ownerWebId, }) {
+        const operation = createAddressBook(containerUri, name);
+        await executeUpdate(this.fetcher, this.updater, operation);
+        if (ownerWebId) {
+            await this.updatePrivateTypeIndex(ownerWebId, operation.uri);
+        }
+        return operation.uri;
+    }
+    async updatePrivateTypeIndex(ownerWebId, addressBookUri) {
+        const profileNode = (0,external_rdflib_.sym)(ownerWebId);
+        await this.support.fetchNode(profileNode);
+        const profileQuery = new ProfileQuery(profileNode, this.store);
+        const preferencesFile = profileQuery.queryPreferencesFile();
+        const privateTypeIndex = await this.fetchPrivateTypeIndex(profileNode, preferencesFile);
+        if (!privateTypeIndex) {
+            throw new Error(`Private type not found for WebID ${ownerWebId}.`);
+        }
+        const operation = addInstanceToTypeIndex(privateTypeIndex, addressBookUri, VCARD_ADDRESS_BOOK);
+        await executeUpdate(this.fetcher, this.updater, operation);
+    }
+    async createNewContact({ addressBookUri, contact, groupUris, }) {
+        const contactQuery = await this.executeCreateNewContact(addressBookUri, contact);
+        await this.executeAddContactToGroups(groupUris, contactQuery);
+        return contactQuery.contactNode.uri;
+    }
+    async executeAddContactToGroups(groupUris, contactQuery) {
+        const groupNodes = (groupUris ?? []).map((it) => (0,external_rdflib_.sym)(it));
+        await this.support.fetchAll(groupNodes);
+        const groupUpdates = groupNodes.map((groupNode) => {
+            const groupQuery = new GroupQuery(this.store, groupNode);
+            const operation = addContactToGroup(contactQuery, groupQuery);
+            return executeUpdate(this.fetcher, this.updater, operation);
+        });
+        await Promise.allSettled(groupUpdates);
+    }
+    async executeCreateNewContact(addressBookUri, contact) {
+        const addressBookNode = (0,external_rdflib_.sym)(addressBookUri);
+        await this.support.fetchNode(addressBookNode);
+        const operation = createNewContact(new AddressBookQuery(this.store, addressBookNode), contact);
+        await executeUpdate(this.fetcher, this.updater, operation);
+        return new ContactQuery(this.store, (0,external_rdflib_.sym)(operation.uri));
+    }
+    async readContact(uri) {
+        const contactNode = (0,external_rdflib_.sym)(uri);
+        await this.support.fetchNode(contactNode);
+        const query = new ContactQuery(this.store, contactNode);
+        const name = query.queryName();
+        const emails = query.queryEmails();
+        const phoneNumbers = query.queryPhoneNumbers();
+        return {
+            uri,
+            name,
+            emails,
+            phoneNumbers,
+        };
+    }
+    async createNewGroup({ addressBookUri, groupName }) {
+        const addressBookNode = (0,external_rdflib_.sym)(addressBookUri);
+        await this.support.fetchNode(addressBookNode);
+        const query = new AddressBookQuery(this.store, addressBookNode);
+        const operation = createNewGroup(query, groupName);
+        await executeUpdate(this.fetcher, this.updater, operation);
+        return operation.uri;
+    }
+    async readGroup(uri) {
+        const groupNode = (0,external_rdflib_.sym)(uri);
+        await this.support.fetchNode(groupNode);
+        const query = new GroupQuery(this.store, groupNode);
+        const name = query.queryName();
+        const members = query.queryMembers();
+        return {
+            uri,
+            name,
+            members,
+        };
+    }
+    async addContactToGroup({ contactUri, groupUri }) {
+        const contactNode = (0,external_rdflib_.sym)(contactUri);
+        const groupNode = (0,external_rdflib_.sym)(groupUri);
+        await this.support.fetchNode(contactNode);
+        const contactQuery = new ContactQuery(this.store, contactNode);
+        const groupQuery = new GroupQuery(this.store, groupNode);
+        const operation = addContactToGroup(contactQuery, groupQuery);
+        await executeUpdate(this.fetcher, this.updater, operation);
+    }
+    async removeContactFromGroup({ contactUri, groupUri, }) {
+        const contactNode = (0,external_rdflib_.sym)(contactUri);
+        const groupNode = (0,external_rdflib_.sym)(groupUri);
+        await this.support.fetchNode(groupNode);
+        const contactQuery = new ContactQuery(this.store, contactNode);
+        const groupQuery = new GroupQuery(this.store, groupNode);
+        const operation = removeContactFromGroup(contactQuery, groupQuery);
+        await executeUpdate(this.fetcher, this.updater, operation);
+    }
+    async addNewPhoneNumber({ contactUri, newPhoneNumber, }) {
+        const contactNode = (0,external_rdflib_.sym)(contactUri);
+        const operation = addNewPhoneNumber(contactNode, newPhoneNumber);
+        await executeUpdate(this.fetcher, this.updater, operation);
+        return operation.uri;
+    }
+    async addNewEmailAddress({ contactUri, newEmailAddress, }) {
+        const contactNode = (0,external_rdflib_.sym)(contactUri);
+        const operation = addNewEmailAddress(contactNode, newEmailAddress);
+        await executeUpdate(this.fetcher, this.updater, operation);
+        return operation.uri;
+    }
+    async removePhoneNumber({ contactUri, phoneNumberUri, }) {
+        const contactNode = (0,external_rdflib_.sym)(contactUri);
+        const phoneNumberNode = (0,external_rdflib_.sym)(phoneNumberUri);
+        await this.support.fetchNode(phoneNumberNode);
+        const operation = removePhoneNumber(contactNode, phoneNumberNode, this.store);
+        await executeUpdate(this.fetcher, this.updater, operation);
+    }
+    async removeEmailAddress({ contactUri, emailAddressUri, }) {
+        const contactNode = (0,external_rdflib_.sym)(contactUri);
+        const emailAddressNode = (0,external_rdflib_.sym)(emailAddressUri);
+        await this.support.fetchNode(emailAddressNode);
+        const operation = removeEmailAddress(contactNode, emailAddressNode, this.store);
+        await executeUpdate(this.fetcher, this.updater, operation);
+    }
+    async updatePhoneNumber({ phoneNumberUri, newPhoneNumber, }) {
+        const phoneNumberNode = (0,external_rdflib_.sym)(phoneNumberUri);
+        await this.support.fetchNode(phoneNumberNode);
+        const operation = updatePhoneNumber(phoneNumberNode, newPhoneNumber, this.store);
+        await executeUpdate(this.fetcher, this.updater, operation);
+    }
+    async updateEmailAddress({ emailAddressUri, newEmailAddress, }) {
+        const emailAddressNode = (0,external_rdflib_.sym)(emailAddressUri);
+        await this.support.fetchNode(emailAddressNode);
+        const operation = updateEmailAddress(emailAddressNode, newEmailAddress, this.store);
+        await executeUpdate(this.fetcher, this.updater, operation);
+    }
+    async listAddressBooks(webId) {
+        const profileNode = (0,external_rdflib_.sym)(webId);
+        await this.support.fetchNode(profileNode);
+        const profileQuery = new ProfileQuery(profileNode, this.store);
+        const publicTypeIndexNode = profileQuery.queryPublicTypeIndex();
+        const preferencesFile = profileQuery.queryPreferencesFile();
+        const promisePublicUris = this.fetchIndexedAddressBooks(publicTypeIndexNode);
+        const promisePrivateTypeIndex = this.fetchPrivateTypeIndex(profileNode, preferencesFile);
+        const [publicUris, privateTypeIndex] = await Promise.allSettled([
+            promisePublicUris,
+            promisePrivateTypeIndex,
+        ]);
+        const privateUris = privateTypeIndex.status === "fulfilled"
+            ? await this.fetchIndexedAddressBooks(privateTypeIndex.value)
+            : [];
+        return {
+            publicUris: publicUris.status === "fulfilled" ? publicUris.value : [],
+            privateUris,
+        };
+    }
+    async fetchIndexedAddressBooks(publicTypeIndexNode) {
+        if (!publicTypeIndexNode) {
+            return [];
+        }
+        await this.support.fetchNode(publicTypeIndexNode);
+        return new TypeIndexQuery(this.store, publicTypeIndexNode).queryInstancesForClass(VCARD_ADDRESS_BOOK);
+    }
+    async fetchPrivateTypeIndex(profileNode, preferencesFile) {
+        if (!preferencesFile) {
+            return null;
+        }
+        await this.support.fetchNode(preferencesFile);
+        const preferencesQuery = new PreferencesQuery(this.store, profileNode, preferencesFile);
+        return preferencesQuery.queryPrivateTypeIndex();
+    }
+    async renameContact({ contactUri, newName }) {
+        const contactNode = (0,external_rdflib_.sym)(contactUri);
+        await this.support.fetchNode(contactNode);
+        const operation = renameContact(this.store, contactNode, newName);
+        await executeUpdate(this.fetcher, this.updater, operation);
+    }
+}
+//# sourceMappingURL=ContactsModuleRdfLib.js.map
+;// ./node_modules/@solid-data-modules/contacts-rdflib/dist/index.js
+
+/* harmony default export */ const dist = (ContactsModuleRdfLib);
+//# sourceMappingURL=index.js.map
+
+/***/ }
+
+}]);
+//# sourceMappingURL=303.profile-pane.js.map