@pod-os/core 0.11.2-fe7524c.0 → 0.12.1-eddb6ac.0

package/dist/dist-762OQHAF.js

@@ -0,0 +1,912 @@
+import {
+  Namespace,
+  isNamedNode,
+  lit,
+  namedNode,
+  st
+} from "./chunk-7C7N3OSJ.js";
+import {
+  __commonJS,
+  __toESM
+} from "./chunk-5NEDDTD5.js";
+
+// ../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, module) {
+    "use strict";
+    var ShortUniqueId2 = (() => {
+      var __defProp = Object.defineProperty;
+      var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+      var __getOwnPropNames = Object.getOwnPropertyNames;
+      var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+      var __hasOwnProp = Object.prototype.hasOwnProperty;
+      var __propIsEnum = Object.prototype.propertyIsEnumerable;
+      var __defNormalProp = (obj, 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);
+        return value;
+      };
+      var src_exports = {};
+      __export(src_exports, {
+        DEFAULT_OPTIONS: () => DEFAULT_OPTIONS,
+        DEFAULT_UUID_LENGTH: () => DEFAULT_UUID_LENGTH,
+        default: () => ShortUniqueId3
+      });
+      var version = "5.2.0";
+      var DEFAULT_UUID_LENGTH = 6;
+      var DEFAULT_OPTIONS = {
+        dictionary: "alphanum",
+        shuffle: true,
+        debug: false,
+        length: DEFAULT_UUID_LENGTH,
+        counter: 0
+      };
+      var _ShortUniqueId = class _ShortUniqueId {
+        constructor(argOptions = {}) {
+          __publicField(this, "counter");
+          __publicField(this, "debug");
+          __publicField(this, "dict");
+          __publicField(this, "version");
+          __publicField(this, "dictIndex", 0);
+          __publicField(this, "dictRange", []);
+          __publicField(this, "lowerBound", 0);
+          __publicField(this, "upperBound", 0);
+          __publicField(this, "dictLength", 0);
+          __publicField(this, "uuidLength");
+          __publicField(this, "_digit_first_ascii", 48);
+          __publicField(this, "_digit_last_ascii", 58);
+          __publicField(this, "_alpha_lower_first_ascii", 97);
+          __publicField(this, "_alpha_lower_last_ascii", 123);
+          __publicField(this, "_hex_last_ascii", 103);
+          __publicField(this, "_alpha_upper_first_ascii", 65);
+          __publicField(this, "_alpha_upper_last_ascii", 91);
+          __publicField(this, "_number_dict_ranges", {
+            digits: [this._digit_first_ascii, this._digit_last_ascii]
+          });
+          __publicField(this, "_alpha_dict_ranges", {
+            lowerCase: [this._alpha_lower_first_ascii, this._alpha_lower_last_ascii],
+            upperCase: [this._alpha_upper_first_ascii, this._alpha_upper_last_ascii]
+          });
+          __publicField(this, "_alpha_lower_dict_ranges", {
+            lowerCase: [this._alpha_lower_first_ascii, this._alpha_lower_last_ascii]
+          });
+          __publicField(this, "_alpha_upper_dict_ranges", {
+            upperCase: [this._alpha_upper_first_ascii, this._alpha_upper_last_ascii]
+          });
+          __publicField(this, "_alphanum_dict_ranges", {
+            digits: [this._digit_first_ascii, this._digit_last_ascii],
+            lowerCase: [this._alpha_lower_first_ascii, this._alpha_lower_last_ascii],
+            upperCase: [this._alpha_upper_first_ascii, this._alpha_upper_last_ascii]
+          });
+          __publicField(this, "_alphanum_lower_dict_ranges", {
+            digits: [this._digit_first_ascii, this._digit_last_ascii],
+            lowerCase: [this._alpha_lower_first_ascii, this._alpha_lower_last_ascii]
+          });
+          __publicField(this, "_alphanum_upper_dict_ranges", {
+            digits: [this._digit_first_ascii, this._digit_last_ascii],
+            upperCase: [this._alpha_upper_first_ascii, this._alpha_upper_last_ascii]
+          });
+          __publicField(this, "_hex_dict_ranges", {
+            decDigits: [this._digit_first_ascii, this._digit_last_ascii],
+            alphaDigits: [this._alpha_lower_first_ascii, this._hex_last_ascii]
+          });
+          __publicField(this, "_dict_ranges", {
+            _number_dict_ranges: this._number_dict_ranges,
+            _alpha_dict_ranges: this._alpha_dict_ranges,
+            _alpha_lower_dict_ranges: this._alpha_lower_dict_ranges,
+            _alpha_upper_dict_ranges: this._alpha_upper_dict_ranges,
+            _alphanum_dict_ranges: this._alphanum_dict_ranges,
+            _alphanum_lower_dict_ranges: this._alphanum_lower_dict_ranges,
+            _alphanum_upper_dict_ranges: this._alphanum_upper_dict_ranges,
+            _hex_dict_ranges: this._hex_dict_ranges
+          });
+          __publicField(this, "log", (...args) => {
+            const finalArgs = [...args];
+            finalArgs[0] = `[short-unique-id] ${args[0]}`;
+            if (this.debug === true) {
+              if (typeof console !== "undefined" && console !== null) {
+                return console.log(...finalArgs);
+              }
+            }
+          });
+          __publicField(this, "_normalizeDictionary", (dictionary2, shuffle2) => {
+            let finalDict;
+            if (dictionary2 && Array.isArray(dictionary2) && dictionary2.length > 1) {
+              finalDict = dictionary2;
+            } else {
+              finalDict = [];
+              let i;
+              this.dictIndex = i = 0;
+              const rangesName = `_${dictionary2}_dict_ranges`;
+              const ranges = this._dict_ranges[rangesName];
+              Object.keys(ranges).forEach((rangeType) => {
+                const rangeTypeKey = rangeType;
+                this.dictRange = ranges[rangeTypeKey];
+                this.lowerBound = this.dictRange[0];
+                this.upperBound = this.dictRange[1];
+                for (this.dictIndex = i = this.lowerBound; this.lowerBound <= this.upperBound ? i < this.upperBound : i > this.upperBound; this.dictIndex = this.lowerBound <= this.upperBound ? i += 1 : i -= 1) {
+                  finalDict.push(String.fromCharCode(this.dictIndex));
+                }
+              });
+            }
+            if (shuffle2) {
+              const PROBABILITY = 0.5;
+              finalDict = finalDict.sort(() => Math.random() - PROBABILITY);
+            }
+            return finalDict;
+          });
+          __publicField(this, "setDictionary", (dictionary2, shuffle2) => {
+            this.dict = this._normalizeDictionary(dictionary2, shuffle2);
+            this.dictLength = this.dict.length;
+            this.setCounter(0);
+          });
+          __publicField(this, "seq", () => {
+            return this.sequentialUUID();
+          });
+          __publicField(this, "sequentialUUID", () => {
+            let counterDiv;
+            let counterRem;
+            let id = "";
+            counterDiv = this.counter;
+            do {
+              counterRem = counterDiv % this.dictLength;
+              counterDiv = Math.trunc(counterDiv / this.dictLength);
+              id += this.dict[counterRem];
+            } while (counterDiv !== 0);
+            this.counter += 1;
+            return id;
+          });
+          __publicField(this, "rnd", (uuidLength = this.uuidLength || DEFAULT_UUID_LENGTH) => {
+            return this.randomUUID(uuidLength);
+          });
+          __publicField(this, "randomUUID", (uuidLength = this.uuidLength || DEFAULT_UUID_LENGTH) => {
+            let id;
+            let randomPartIdx;
+            let j;
+            if (uuidLength === null || typeof uuidLength === "undefined" || uuidLength < 1) {
+              throw new Error("Invalid UUID Length Provided");
+            }
+            const isPositive = uuidLength >= 0;
+            id = "";
+            for (j = 0; j < uuidLength; j += 1) {
+              randomPartIdx = parseInt(
+                (Math.random() * this.dictLength).toFixed(0),
+                10
+              ) % this.dictLength;
+              id += this.dict[randomPartIdx];
+            }
+            return id;
+          });
+          __publicField(this, "fmt", (format, date) => {
+            return this.formattedUUID(format, date);
+          });
+          __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 = 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;
+          });
+          __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 score = parseFloat(
+              (1 - this.approxMaxBeforeCollision(rounds) / rounds).toFixed(20)
+            );
+            return score > 1 ? 1 : score < 0 ? 0 : score;
+          });
+          __publicField(this, "getVersion", () => {
+            return this.version;
+          });
+          __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 `${id.substring(0, rndIdx)}${hexStamp}${id.substring(rndIdx)}${rndIdx.toString(16)}`;
+          });
+          __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 = 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(parseInt(stamp, 16) * 1e3);
+            }
+            if (stamp.length < 10) {
+              throw new Error("Stamp length invalid");
+            }
+            const rndIdx = parseInt(stamp.substring(stamp.length - 1), 16);
+            return new Date(parseInt(stamp.substring(rndIdx, rndIdx + 8), 16) * 1e3);
+          });
+          __publicField(this, "setCounter", (counter2) => {
+            this.counter = counter2;
+          });
+          __publicField(this, "validate", (uid2, dictionary2) => {
+            const finalDictionary = dictionary2 ? this._normalizeDictionary(dictionary2) : this.dict;
+            return uid2.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 ${this.dictLength} and counter set to ${this.counter}`
+          );
+          this.log = this.log.bind(this);
+          this.setDictionary = this.setDictionary.bind(this);
+          this.setCounter = this.setCounter.bind(this);
+          this.seq = this.seq.bind(this);
+          this.sequentialUUID = this.sequentialUUID.bind(this);
+          this.rnd = this.rnd.bind(this);
+          this.randomUUID = this.randomUUID.bind(this);
+          this.fmt = this.fmt.bind(this);
+          this.formattedUUID = this.formattedUUID.bind(this);
+          this.availableUUIDs = this.availableUUIDs.bind(this);
+          this.approxMaxBeforeCollision = this.approxMaxBeforeCollision.bind(this);
+          this.collisionProbability = this.collisionProbability.bind(this);
+          this.uniqueness = this.uniqueness.bind(this);
+          this.getVersion = this.getVersion.bind(this);
+          this.stamp = this.stamp.bind(this);
+          this.parseStamp = this.parseStamp.bind(this);
+          return this;
+        }
+      };
+      __publicField(_ShortUniqueId, "default", _ShortUniqueId);
+      var ShortUniqueId3 = _ShortUniqueId;
+      return __toCommonJS(src_exports);
+    })();
+    "undefined" != typeof module && (module.exports = ShortUniqueId2.default), "undefined" != typeof window && (ShortUniqueId2 = ShortUniqueId2.default);
+  }
+});
+
+// ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/namespaces.js
+var rdf = Namespace("http://www.w3.org/1999/02/22-rdf-syntax-ns#");
+var vcard = Namespace("http://www.w3.org/2006/vcard/ns#");
+var solid = Namespace("http://www.w3.org/ns/solid/terms#");
+var pim = Namespace("http://www.w3.org/ns/pim/space#");
+var dc = Namespace("http://purl.org/dc/elements/1.1/");
+
+// ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/generate-id.js
+var import_short_unique_id = __toESM(require_short_unique_id(), 1);
+var uid = new import_short_unique_id.default({ length: 10 });
+function generateId() {
+  return uid.rnd(6);
+}
+
+// ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/queries/AddressBookQuery.js
+var AddressBookQuery = class {
+  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 namedNode(`${baseUri}${containerPath}/${id}/index.ttl#this`);
+  }
+  queryTitle() {
+    return this.store.anyValue(this.addressBookNode, dc("title"), void 0, this.addressBookDoc) ?? "";
+  }
+  queryNameEmailIndex() {
+    const index = this.store.any(this.addressBookNode, vcard("nameEmailIndex"), void 0, this.addressBookDoc);
+    if (isNamedNode(index)) {
+      return index;
+    } else {
+      return null;
+    }
+  }
+  queryContacts() {
+    const nameEmailIndex = this.queryNameEmailIndex();
+    return nameEmailIndex && isNamedNode(nameEmailIndex) ? this.store.each(null, vcard("inAddressBook"), this.addressBookNode, nameEmailIndex).filter((it) => 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"), void 0, this.addressBookDoc);
+    if (isNamedNode(index)) {
+      return index;
+    } else {
+      return null;
+    }
+  }
+  queryGroups() {
+    const groupIndex = this.queryGroupIndex();
+    return groupIndex && isNamedNode(groupIndex) ? this.store.each(this.addressBookNode, vcard("includesGroup"), null, groupIndex).filter((it) => isNamedNode(it)).map((node) => ({
+      name: this.store.anyValue(node, vcard("fn"), null, groupIndex) ?? "",
+      uri: node.value
+    })) : [];
+  }
+};
+
+// ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/queries/ContactQuery.js
+var MAILTO_URI_SCHEME = "mailto:";
+var TEl_URI_SCHEME = "tel:";
+var ContactQuery = class {
+  constructor(store, contactNode) {
+    this.store = store;
+    this.contactNode = contactNode;
+    this.contactDoc = contactNode.doc();
+  }
+  queryName() {
+    return this.store.anyValue(this.contactNode, vcard("fn"), void 0, 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, void 0, this.contactDoc).map((it) => it.object.value);
+  }
+  getValueNode(uri) {
+    return this.store.any(namedNode(uri), vcard("value"), void 0, this.contactDoc);
+  }
+};
+function isMailtoNode(valueNode) {
+  return isNamedNode(valueNode) && valueNode.value.startsWith(MAILTO_URI_SCHEME);
+}
+function isTelNode(valueNode) {
+  return isNamedNode(valueNode) && valueNode.value.startsWith(TEl_URI_SCHEME);
+}
+
+// ../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 = [
+    st(namedNode(uri), namedNode("http://www.w3.org/1999/02/22-rdf-syntax-ns#type"), vcard("AddressBook"), namedNode(uri).doc()),
+    st(namedNode(uri), dc("title"), lit(name), namedNode(uri).doc()),
+    st(namedNode(uri), vcard("nameEmailIndex"), namedNode(nameEmailIndexUri), namedNode(uri).doc()),
+    st(namedNode(uri), vcard("groupIndex"), namedNode(groupIndexUri), namedNode(uri).doc())
+  ];
+  return {
+    uri,
+    deletions: [],
+    insertions,
+    filesToCreate: [{ uri: nameEmailIndexUri }, { uri: groupIndexUri }]
+  };
+}
+
+// ../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 = [
+    st(contactNode, vcard("inAddressBook"), addressBook.addressBookNode, nameEmailIndex),
+    st(contactNode, vcard("fn"), lit(newContact.name), nameEmailIndex),
+    st(contactNode, vcard("fn"), lit(newContact.name), contactNode.doc()),
+    st(contactNode, rdf("type"), vcard("Individual"), contactNode.doc())
+  ];
+  if (newContact.email) {
+    const emailNode = namedNode(contactNode.doc().uri + "#email");
+    insertions.push(st(contactNode, vcard("hasEmail"), emailNode, contactNode.doc()), st(emailNode, vcard("value"), namedNode("mailto:" + newContact.email), contactNode.doc()));
+  }
+  if (newContact.phoneNumber) {
+    const phoneNode = namedNode(contactNode.doc().uri + "#phone");
+    insertions.push(st(contactNode, vcard("hasTelephone"), phoneNode, contactNode.doc()), st(phoneNode, vcard("value"), namedNode("tel:" + newContact.phoneNumber), contactNode.doc()));
+  }
+  return {
+    uri: contactNode.uri,
+    deletions: [],
+    insertions,
+    filesToCreate: []
+  };
+}
+
+// ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/web-operations/executeUpdate.js
+async function executeUpdate(fetcher, updater, operation) {
+  await updater.updateMany(operation.deletions, operation.insertions);
+  operation.filesToCreate.map((file) => {
+    createEmptyTurtleFile(fetcher, file.uri);
+  });
+}
+function createEmptyTurtleFile(fetcher, uri) {
+  return fetcher.webOperation("PUT", uri, {
+    contentType: "text/turtle"
+  });
+}
+
+// ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/web-operations/fetchNode.js
+async function fetchNode(fetcher, node) {
+  if (node) {
+    await fetcher.load(node.value);
+  }
+}
+
+// ../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: [
+      st(groupNode, vcard("fn"), lit(groupName), groupIndex),
+      st(groupNode, vcard("fn"), lit(groupName), groupDoc),
+      st(groupNode, rdf("type"), vcard("Group"), groupDoc),
+      st(addressBook.addressBookNode, vcard("includesGroup"), groupNode, groupIndex)
+    ],
+    deletions: [],
+    filesToCreate: []
+  };
+}
+
+// ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/queries/GroupQuery.js
+var GroupQuery = class {
+  constructor(store, groupNode) {
+    this.store = store;
+    this.groupNode = groupNode;
+    this.groupDoc = groupNode.doc();
+  }
+  queryName() {
+    return this.store.anyValue(this.groupNode, vcard("fn"), void 0, this.groupDoc) ?? "";
+  }
+  queryMembers() {
+    return this.store.each(this.groupNode, vcard("hasMember"), null, this.groupDoc).filter((it) => isNamedNode(it)).map((node) => ({
+      uri: node.value,
+      name: this.store.anyValue(node, vcard("fn"), null, this.groupDoc) ?? ""
+    }));
+  }
+};
+
+// ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/update-operations/addContactToGroup.js
+function addContactToGroup(contactQuery, groupQuery) {
+  const name = contactQuery.queryName();
+  return {
+    uri: "",
+    insertions: [
+      st(groupQuery.groupNode, vcard("hasMember"), contactQuery.contactNode, groupQuery.groupNode.doc()),
+      st(contactQuery.contactNode, vcard("fn"), lit(name), groupQuery.groupNode.doc())
+    ],
+    deletions: [],
+    filesToCreate: []
+  };
+}
+
+// ../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 {
+    uri: "",
+    insertions: [],
+    deletions: [
+      st(groupQuery.groupNode, vcard("hasMember"), contactQuery.contactNode, groupQuery.groupNode.doc()),
+      st(contactQuery.contactNode, vcard("fn"), lit(member.name), groupQuery.groupNode.doc())
+    ],
+    filesToCreate: []
+  };
+}
+
+// ../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: [
+      st(contactNode, vcard("hasTelephone"), namedNode(uri), contactNode.doc()),
+      st(namedNode(uri), vcard("value"), namedNode("tel:" + phoneNumber), contactNode.doc())
+    ],
+    deletions: [],
+    filesToCreate: []
+  };
+}
+
+// ../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: [
+      st(contactNode, vcard("hasEmail"), namedNode(uri), contactNode.doc()),
+      st(namedNode(uri), vcard("value"), namedNode("mailto:" + emailAddress), contactNode.doc())
+    ],
+    deletions: [],
+    filesToCreate: []
+  };
+}
+
+// ../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,
+      st(contactNode, vcard("hasTelephone"), phoneNode, contactNode.doc())
+    ],
+    filesToCreate: []
+  };
+}
+
+// ../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,
+      st(contactNode, vcard("hasEmail"), emailNode, contactNode.doc())
+    ],
+    filesToCreate: []
+  };
+}
+
+// ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/queries/ProfileQuery.js
+var ProfileQuery = class {
+  constructor(webIdNode, store) {
+    this.webIdNode = webIdNode;
+    this.store = store;
+  }
+  queryPublicTypeIndex() {
+    const predicate = solid("publicTypeIndex");
+    return this.queryNamedNode(predicate);
+  }
+  queryPreferencesFile() {
+    const predicate = pim("preferencesFile");
+    return this.queryNamedNode(predicate);
+  }
+  queryNamedNode(predicate) {
+    const node = this.store.any(this.webIdNode, predicate, null, this.webIdNode.doc());
+    if (isNamedNode(node)) {
+      return node;
+    }
+    return null;
+  }
+};
+
+// ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/queries/TypeIndexQuery.js
+var 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 = class {
+  constructor(store, webIdNode, preferencesDoc) {
+    this.store = store;
+    this.webIdNode = webIdNode;
+    this.preferencesDoc = preferencesDoc;
+  }
+  queryPrivateTypeIndex() {
+    const node = this.store.any(this.webIdNode, solid("privateTypeIndex"), null, this.preferencesDoc);
+    if (isNamedNode(node)) {
+      return node;
+    }
+    return null;
+  }
+};
+
+// ../node_modules/@solid-data-modules/contacts-rdflib/dist/rdflib/ContactsModuleRdfLib.js
+var ContactsModuleRdfLib = class {
+  constructor(config) {
+    this.store = config.store;
+    this.fetcher = config.fetcher;
+    this.updater = config.updater;
+  }
+  async readAddressBook(uri) {
+    const addressBookNode = namedNode(uri);
+    await this.fetchNode(addressBookNode);
+    const query = new AddressBookQuery(this.store, addressBookNode);
+    const title = query.queryTitle();
+    const nameEmailIndex = query.queryNameEmailIndex();
+    const groupIndex = query.queryGroupIndex();
+    await Promise.allSettled([
+      this.fetchNode(nameEmailIndex),
+      this.fetchNode(groupIndex)
+    ]);
+    await this.fetchAll([nameEmailIndex, groupIndex]);
+    const contacts = query.queryContacts();
+    const groups = query.queryGroups();
+    return {
+      uri,
+      title,
+      contacts,
+      groups
+    };
+  }
+  async fetchNode(node) {
+    return fetchNode(this.fetcher, node);
+  }
+  async fetchAll(nodes) {
+    return Promise.all(nodes.map((it) => this.fetchNode(it)));
+  }
+  async createAddressBook({ containerUri, name }) {
+    const operation = createAddressBook(containerUri, name);
+    await executeUpdate(this.fetcher, this.updater, operation);
+    return operation.uri;
+  }
+  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) => namedNode(it));
+    await this.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 = namedNode(addressBookUri);
+    await this.fetchNode(addressBookNode);
+    const operation = createNewContact(new AddressBookQuery(this.store, addressBookNode), contact);
+    await executeUpdate(this.fetcher, this.updater, operation);
+    return new ContactQuery(this.store, namedNode(operation.uri));
+  }
+  async readContact(uri) {
+    const contactNode = namedNode(uri);
+    await this.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 = namedNode(addressBookUri);
+    await this.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 = namedNode(uri);
+    await this.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 = namedNode(contactUri);
+    const groupNode = namedNode(groupUri);
+    await this.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 = namedNode(contactUri);
+    const groupNode = namedNode(groupUri);
+    await this.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 = namedNode(contactUri);
+    const operation = addNewPhoneNumber(contactNode, newPhoneNumber);
+    await executeUpdate(this.fetcher, this.updater, operation);
+    return operation.uri;
+  }
+  async addNewEmailAddress({ contactUri, newEmailAddress }) {
+    const contactNode = namedNode(contactUri);
+    const operation = addNewEmailAddress(contactNode, newEmailAddress);
+    await executeUpdate(this.fetcher, this.updater, operation);
+    return operation.uri;
+  }
+  async removePhoneNumber({ contactUri, phoneNumberUri }) {
+    const contactNode = namedNode(contactUri);
+    const phoneNumberNode = namedNode(phoneNumberUri);
+    await this.fetchNode(phoneNumberNode);
+    const operation = removePhoneNumber(contactNode, phoneNumberNode, this.store);
+    await executeUpdate(this.fetcher, this.updater, operation);
+  }
+  async removeEmailAddress({ contactUri, emailAddressUri }) {
+    const contactNode = namedNode(contactUri);
+    const emailAddressNode = namedNode(emailAddressUri);
+    await this.fetchNode(emailAddressNode);
+    const operation = removeEmailAddress(contactNode, emailAddressNode, this.store);
+    await executeUpdate(this.fetcher, this.updater, operation);
+  }
+  async listAddressBooks(webId) {
+    const profileNode = namedNode(webId);
+    await this.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.fetchNode(publicTypeIndexNode);
+    return new TypeIndexQuery(this.store, publicTypeIndexNode).queryAddressBookInstances();
+  }
+  async fetchPrivateTypeIndex(profileNode, preferencesFile) {
+    if (!preferencesFile) {
+      return null;
+    }
+    await this.fetchNode(preferencesFile);
+    const preferencesQuery = new PreferencesQuery(this.store, profileNode, preferencesFile);
+    return preferencesQuery.queryPrivateTypeIndex();
+  }
+};
+
+// ../node_modules/@solid-data-modules/contacts-rdflib/dist/index.js
+var dist_default = ContactsModuleRdfLib;
+export {
+  dist_default as default
+};