@cocreate/utils 1.42.1 → 1.42.2

package/dist/cjs/dataQuery.js

@@ -0,0 +1,280 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 dataQuery_exports = {};
+__export(dataQuery_exports, {
+  queryData: () => queryData,
+  searchData: () => searchData,
+  sortData: () => sortData
+});
+module.exports = __toCommonJS(dataQuery_exports);
+var import_getValueFromObject = require("./getValueFromObject.js");
+var import_isValidDate = require("./isValidDate.js");
+function isEqualArray(arr1, arr2) {
+  if (arr1.length !== arr2.length) {
+    return false;
+  }
+  for (let i = 0; i < arr1.length; i++) {
+    if (!isEqualObject(arr1[i], arr2[i])) {
+      return false;
+    }
+  }
+  return true;
+}
+function isEqualObject(obj1, obj2) {
+  const keys1 = Object.keys(obj1);
+  const keys2 = Object.keys(obj2);
+  if (keys1.length !== keys2.length) {
+    return false;
+  }
+  for (const key of keys1) {
+    if (obj1[key] !== obj2[key]) {
+      return false;
+    }
+  }
+  return true;
+}
+function queryMatch(data, query) {
+  for (let key of Object.keys(query)) {
+    let dataValue;
+    try {
+      dataValue = (0, import_getValueFromObject.getValueFromObject)(data, key, true);
+    } catch (error) {
+      return false;
+    }
+    if (typeof query[key] === "string" || typeof query[key] === "number" || typeof query[key] === "boolean") {
+      if (Array.isArray(dataValue)) return dataValue.includes(query[key]);
+      else return dataValue === query[key];
+    } else if (Array.isArray(query[key])) {
+      if (Array.isArray(dataValue)) {
+        return isEqualArray(dataValue, query[key]);
+      } else {
+        return false;
+      }
+    } else {
+      for (let property of Object.keys(query[key])) {
+        if (property === "$options") continue;
+        if (!property.startsWith("$")) {
+          if (typeof dataValue !== "object") {
+            return false;
+          } else
+            return queryMatch(
+              { [property]: (0, import_getValueFromObject.getValueFromObject)(dataValue, property) },
+              { [property]: query[key][property] }
+            );
+        } else {
+          let queryValue = query[key][property];
+          if ((0, import_isValidDate.isValidDate)(queryValue) && (0, import_isValidDate.isValidDate)(dataValue)) {
+            queryValue = new Date(queryValue);
+            dataValue = new Date(dataValue);
+          }
+          let queryStatus = false;
+          switch (property) {
+            case "$eq":
+              if (Array.isArray(dataValue) && Array.isArray(queryValue)) {
+                queryStatus = isEqualArray(dataValue, queryValue);
+              } else {
+                queryStatus = dataValue === queryValue;
+              }
+              break;
+            case "$ne":
+              if (Array.isArray(dataValue) && Array.isArray(queryValue)) {
+                queryStatus = !isEqualArray(dataValue, queryValue);
+              } else {
+                queryStatus = dataValue !== queryValue;
+              }
+              break;
+            case "$not":
+              queryStatus = !queryMatch(data, {
+                [key]: query[key]["$not"]
+              });
+              break;
+            case "$lt":
+              queryStatus = dataValue < queryValue;
+              break;
+            case "$lte":
+              queryStatus = dataValue <= queryValue;
+              break;
+            case "$gt":
+              queryStatus = dataValue > queryValue;
+              break;
+            case "$gte":
+              queryStatus = dataValue >= queryValue;
+              break;
+            case "$in":
+              if (Array.isArray(dataValue)) {
+                queryStatus = dataValue.some(
+                  (element) => queryValue.includes(element)
+                );
+              } else {
+                queryStatus = queryValue.includes(dataValue);
+              }
+              break;
+            case "$nin":
+              if (Array.isArray(dataValue)) {
+                queryStatus = !dataValue.some(
+                  (element) => queryValue.includes(element)
+                );
+              } else {
+                queryStatus = !queryValue.includes(dataValue);
+              }
+              break;
+            case "$all":
+              if (Array.isArray(dataValue) && Array.isArray(queryValue)) {
+                queryStatus = queryValue.every(
+                  (element) => dataValue.includes(element)
+                );
+              }
+              break;
+            case "$elemMatch":
+              if (Array.isArray(data[key])) {
+                queryStatus = data[key].some(
+                  (element) => queryMatch(element, query[key][property])
+                );
+              }
+              break;
+            case "$size":
+              if (Array.isArray(dataValue)) {
+                queryStatus = dataValue.length === queryValue;
+              }
+              break;
+            case "$exists":
+              queryStatus = queryValue ? data.hasOwnProperty(key) : !data.hasOwnProperty(key);
+              break;
+            case "$regex":
+              if (typeof dataValue === "string") {
+                let regexFlag = query[key]["$options"] || "";
+                let regex = new RegExp(queryValue, regexFlag);
+                queryStatus = regex.test(dataValue);
+              }
+              break;
+            case "$type":
+              let dataType = typeof dataValue;
+              if (Array.isArray(dataValue)) {
+                dataType = "array";
+              }
+              queryStatus = dataType === queryValue;
+              break;
+            case "$mod":
+              if (typeof dataValue === "number" && Array.isArray(queryValue) && queryValue.length === 2) {
+                const [divisor, remainder] = queryValue;
+                queryStatus = dataValue % divisor === remainder;
+              }
+              break;
+            case "$where":
+              if (typeof queryValue === "function") {
+                try {
+                } catch (error) {
+                  console.error(
+                    "Error in queryData $where function:",
+                    error
+                  );
+                }
+              }
+              break;
+            default:
+              console.log("unknown operator");
+              break;
+          }
+          if (!queryStatus) return false;
+        }
+      }
+      return true;
+    }
+  }
+}
+function queryData(data, query) {
+  if (query.$and) {
+    for (let i = 0; i < query.$and.length; i++) {
+      if (!queryData(data, query.$and[i])) return false;
+    }
+  }
+  if (query.$nor) {
+    for (let i = 0; i < query.$nor.length; i++) {
+      if (queryData(data, query.$nor[i])) return false;
+    }
+  }
+  for (let key of Object.keys(query)) {
+    if (key === "$and" || key === "$or") continue;
+    if (!queryMatch(data, { [key]: query[key] })) return false;
+  }
+  if (query.$or) {
+    for (let i = 0; i < query.$or.length; i++) {
+      if (queryData(data, query.$or[i])) return true;
+    }
+  }
+  return true;
+}
+function searchData(data, search) {
+  if (!search) return true;
+  if (!Array.isArray(search)) search = [search];
+  for (let i = 0; i < search.length; i++) {
+    let searchValue = search[i].value;
+    if (!Array.isArray(searchValue)) searchValue = [searchValue];
+    for (let key in data) {
+      let value = data[key];
+      let status = false;
+      switch (typeof value) {
+        case "number":
+          value = value.toString();
+          break;
+        case "object":
+          value = JSON.stringify(value);
+          break;
+        case "function":
+          value = value.toString();
+          break;
+      }
+      if (search[i].caseSensitive != "true" || search[i].caseSensitive != true)
+        value = value.toLowerCase();
+      for (let i2 = 0; i2 < searchValue.length; i2++) {
+        let searchString = searchValue[i2];
+        if (search[i2].caseSensitive != "true" || search[i2].caseSensitive != true)
+          searchString = searchString.toLowerCase();
+        if (searchString === "" && search[i2].operator === "and") {
+          if (value !== "") return false;
+        }
+        if (value.indexOf(searchString) > -1) status = true;
+        if (status) return true;
+        else if (search[i2].operator == "and") return false;
+      }
+    }
+    if (search[i].value.length && search[i].operator == "or") return false;
+  }
+  return true;
+}
+function sortData(data, sort) {
+  return data.sort((a, b) => {
+    for (let i = 0; i < sort.length; i++) {
+      let key = sort[i].key;
+      if (a[key] == null && b[key] == null) continue;
+      if (a[key] == null) return sort[i].direction === "desc" ? -1 : 1;
+      if (b[key] == null) return sort[i].direction === "desc" ? 1 : -1;
+      if (typeof a[key] !== typeof b[key]) {
+        return typeof a[key] < typeof b[key] ? -1 : 1;
+      }
+      if (a[key] !== b[key]) {
+        if (typeof a[key] === "string") {
+          return sort[i].direction === "desc" ? b[key].localeCompare(a[key]) : a[key].localeCompare(b[key]);
+        } else {
+          return sort[i].direction === "desc" ? b[key] - a[key] : a[key] - b[key];
+        }
+      }
+    }
+    return 0;
+  });
+}

package/dist/cjs/dom.js

@@ -0,0 +1,29 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 dom_exports = {};
+__export(dom_exports, {
+  cssPath: () => import_cssPath.cssPath,
+  domParser: () => import_domParser.domParser,
+  escapeHtml: () => import_escapeHtml.escapeHtml,
+  parseTextToHtml: () => import_parseTextToHtml.parseTextToHtml
+});
+module.exports = __toCommonJS(dom_exports);
+var import_domParser = require("./domParser.js");
+var import_parseTextToHtml = require("./parseTextToHtml.js");
+var import_escapeHtml = require("./escapeHtml.js");
+var import_cssPath = require("./cssPath.js");

package/dist/cjs/domParser.js

@@ -0,0 +1,44 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 domParser_exports = {};
+__export(domParser_exports, {
+  domParser: () => domParser
+});
+module.exports = __toCommonJS(domParser_exports);
+function domParser(str) {
+  try {
+    var mainTag = str.match(/\<(?<tag>[a-z0-9]+)(.*?)?\>/).groups.tag;
+  } catch (e) {
+  }
+  let doc;
+  switch (mainTag) {
+    case "html":
+      doc = new DOMParser().parseFromString(str, "text/html");
+      return doc.documentElement;
+    case "body":
+      doc = new DOMParser().parseFromString(str, "text/html");
+      return doc.body;
+    case "head":
+      doc = new DOMParser().parseFromString(str, "text/html");
+      return doc.head;
+    default:
+      let con = document.createElement("dom-parser");
+      con.innerHTML = str;
+      return con;
+  }
+}

package/dist/cjs/dotNotationToObject.js

@@ -0,0 +1,103 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 dotNotationToObject_exports = {};
+__export(dotNotationToObject_exports, {
+  dotNotationToObject: () => dotNotationToObject
+});
+module.exports = __toCommonJS(dotNotationToObject_exports);
+function dotNotationToObject(data, obj = {}) {
+  try {
+    let arrayGroup = {};
+    for (const key of Object.keys(data)) {
+      let value = data[key];
+      let newObject = obj;
+      let oldObject = new Object(obj);
+      let keys = key.split(".");
+      let length = keys.length - 1;
+      for (let i = 0; i < keys.length; i++) {
+        if (keys[i].endsWith("]")) {
+          if (keys[i].endsWith("[]")) {
+            let baseKey = keys[i].slice(0, -2);
+            if (!Array.isArray(newObject[baseKey])) {
+              newObject[baseKey] = [];
+            }
+            if (length == i) {
+              if (Array.isArray(value)) {
+                newObject[baseKey].push(...value);
+              } else {
+                newObject[baseKey].push(value);
+              }
+            }
+          } else if (/\[([0-9]+)\]/g.test(keys[i])) {
+            let [k, index] = keys[i].split("[");
+            index = index.slice(0, -1);
+            if (!Array.isArray(newObject[k])) {
+              newObject[k] = [];
+            }
+            if (length == i) {
+              if (value === void 0) {
+                newObject[k].splice(index, 1);
+              } else {
+                newObject[k][index] = value;
+              }
+            } else {
+              newObject[k][index] = oldObject[k][index] || {};
+              newObject = newObject[k][index];
+              oldObject = oldObject[k][index];
+            }
+          } else if (/\[\w\]/g.test(keys[i])) {
+            let [k, group] = keys[i].split("[");
+            group = group.slice(0, -1);
+            if (!Array.isArray(newObject[k])) {
+              newObject[k] = [];
+            }
+            let index;
+            if (arrayGroup[keys.slice(0, i + 1).join(".")]) {
+              index = arrayGroup[keys.slice(0, i + 1).join(".")];
+            } else {
+              index = newObject[k].length;
+              arrayGroup[keys.slice(0, i + 1).join(".")] = index;
+              newObject[k][index] = {};
+            }
+            if (length == i) {
+              newObject[k][index] = value;
+            } else {
+              newObject = newObject[k][index];
+            }
+          }
+        } else {
+          if (length == i) {
+            if (value === void 0) {
+              delete newObject[keys[i]];
+            } else {
+              newObject[keys[i]] = value;
+            }
+          } else {
+            newObject[keys[i]] = oldObject[keys[i]] || {};
+            newObject = newObject[keys[i]];
+            oldObject = oldObject[keys[i]];
+          }
+        }
+      }
+    }
+    return obj;
+  } catch (error) {
+    console.log("Error converting dot notation to object", error);
+    return false;
+  }
+}

package/dist/cjs/escapeHtml.js

@@ -0,0 +1,25 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 escapeHtml_exports = {};
+__export(escapeHtml_exports, {
+  escapeHtml: () => escapeHtml
+});
+module.exports = __toCommonJS(escapeHtml_exports);
+function escapeHtml(html) {
+  return html.replaceAll("&", "&amp").replaceAll("<", "&lt").replaceAll(">", "&gt;").replaceAll("'", "&#39;").replaceAll('"', "&quot;");
+}

package/dist/cjs/getRelativePath.js

@@ -0,0 +1,39 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 getRelativePath_exports = {};
+__export(getRelativePath_exports, {
+  getRelativePath: () => getRelativePath
+});
+module.exports = __toCommonJS(getRelativePath_exports);
+function getRelativePath(path) {
+  const isBrowser = typeof window !== "undefined";
+  if (!path && isBrowser) {
+    path = window.location.pathname.replace(/\/[^\/]*$/, "");
+  }
+  if (isBrowser && (location.hostname === "localhost" || location.hostname === "127.0.0.1")) {
+    const srcIndex = path.indexOf("/src");
+    if (srcIndex !== -1) {
+      path = path.slice(srcIndex + 4);
+    }
+  }
+  if (!path.endsWith("/")) {
+    path += "/";
+  }
+  let depth = path.split("/").filter(Boolean).length;
+  return depth > 0 ? "../".repeat(depth) : "./";
+}

package/dist/cjs/getValueFromObject.js

@@ -0,0 +1,41 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 getValueFromObject_exports = {};
+__export(getValueFromObject_exports, {
+  getValueFromObject: () => getValueFromObject
+});
+module.exports = __toCommonJS(getValueFromObject_exports);
+function getValueFromObject(object = {}, path = "", throwError = false) {
+  try {
+    if (!Array.isArray(object) && !Object.keys(object).length || !path) {
+      if (throwError) throw new Error("Invalid input to getValueFromObject");
+      return;
+    }
+    path = path.replace(/\[(\d+)\]/g, ".$1").replace(/^\./, "");
+    let data = object, subpath = path.split(".");
+    for (let i = 0; i < subpath.length; i++) {
+      if (throwError && !(subpath[i] in data))
+        throw new Error("Key not found in object: " + subpath[i]);
+      data = data[subpath[i]];
+      if (!data) break;
+    }
+    return data;
+  } catch (error) {
+    if (throwError) throw error;
+  }
+}

package/dist/cjs/index.js

@@ -0,0 +1,112 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 index_exports = {};
+__export(index_exports, {
+  ObjectId: () => import_ObjectId.ObjectId,
+  checkMediaQueries: () => import_queryElements.checkMediaQueries,
+  checkValue: () => import_checkValue.checkValue,
+  clickedElement: () => import_clickedElement.clickedElement,
+  createUpdate: () => import_createUpdate.createUpdate,
+  cssPath: () => import_cssPath.cssPath,
+  default: () => index_default,
+  domParser: () => import_domParser.domParser,
+  dotNotationToObject: () => import_dotNotationToObject.dotNotationToObject,
+  escapeHtml: () => import_escapeHtml.escapeHtml,
+  getAttributeNames: () => import_attributes.getAttributeNames,
+  getAttributes: () => import_attributes.getAttributes,
+  getRelativePath: () => import_getRelativePath.getRelativePath,
+  getValueFromObject: () => import_getValueFromObject.getValueFromObject,
+  isValidDate: () => import_isValidDate.isValidDate,
+  objectToDotNotation: () => import_objectToDotNotation.objectToDotNotation,
+  objectToSearchParams: () => import_objectToSearchParams.objectToSearchParams,
+  parseTextToHtml: () => import_parseTextToHtml.parseTextToHtml,
+  processOperators: () => import_operators.processOperators,
+  processOperatorsAsync: () => import_operators.processOperatorsAsync,
+  queryData: () => import_dataQuery.queryData,
+  queryElements: () => import_queryElements.queryElements,
+  searchData: () => import_dataQuery.searchData,
+  setAttributeNames: () => import_attributes.setAttributeNames,
+  sortData: () => import_dataQuery.sortData,
+  uid: () => import_uid.uid
+});
+module.exports = __toCommonJS(index_exports);
+var import_getRelativePath = require("./getRelativePath.js");
+var import_ObjectId = require("./ObjectId.js");
+var import_uid = require("./uid.js");
+var import_checkValue = require("./checkValue.js");
+var import_isValidDate = require("./isValidDate.js");
+var import_objectToSearchParams = require("./objectToSearchParams.js");
+var import_dotNotationToObject = require("./dotNotationToObject.js");
+var import_objectToDotNotation = require("./objectToDotNotation.js");
+var import_getValueFromObject = require("./getValueFromObject.js");
+var import_createUpdate = require("./createUpdate.js");
+var import_domParser = require("./domParser.js");
+var import_parseTextToHtml = require("./parseTextToHtml.js");
+var import_escapeHtml = require("./escapeHtml.js");
+var import_cssPath = require("./cssPath.js");
+var import_queryElements = require("./queryElements.js");
+var import_dataQuery = require("./dataQuery.js");
+var import_attributes = require("./attributes.js");
+var import_clickedElement = require("./clickedElement.js");
+var import_operators = require("./operators.js");
+var import_getRelativePath2 = require("./getRelativePath.js");
+var import_ObjectId2 = require("./ObjectId.js");
+var import_uid2 = require("./uid.js");
+var import_checkValue2 = require("./checkValue.js");
+var import_isValidDate2 = require("./isValidDate.js");
+var import_objectToSearchParams2 = require("./objectToSearchParams.js");
+var import_dotNotationToObject2 = require("./dotNotationToObject.js");
+var import_objectToDotNotation2 = require("./objectToDotNotation.js");
+var import_getValueFromObject2 = require("./getValueFromObject.js");
+var import_createUpdate2 = require("./createUpdate.js");
+var import_domParser2 = require("./domParser.js");
+var import_parseTextToHtml2 = require("./parseTextToHtml.js");
+var import_escapeHtml2 = require("./escapeHtml.js");
+var import_cssPath2 = require("./cssPath.js");
+var import_queryElements2 = require("./queryElements.js");
+var import_dataQuery2 = require("./dataQuery.js");
+var import_attributes2 = require("./attributes.js");
+var import_operators2 = require("./operators.js");
+const utils = {
+  getRelativePath: import_getRelativePath2.getRelativePath,
+  ObjectId: import_ObjectId2.ObjectId,
+  uid: import_uid2.uid,
+  checkValue: import_checkValue2.checkValue,
+  isValidDate: import_isValidDate2.isValidDate,
+  dotNotationToObject: import_dotNotationToObject2.dotNotationToObject,
+  objectToDotNotation: import_objectToDotNotation2.objectToDotNotation,
+  getValueFromObject: import_getValueFromObject2.getValueFromObject,
+  objectToSearchParams: import_objectToSearchParams2.objectToSearchParams,
+  domParser: import_domParser2.domParser,
+  parseTextToHtml: import_parseTextToHtml2.parseTextToHtml,
+  escapeHtml: import_escapeHtml2.escapeHtml,
+  cssPath: import_cssPath2.cssPath,
+  queryElements: import_queryElements2.queryElements,
+  checkMediaQueries: import_queryElements2.checkMediaQueries,
+  queryData: import_dataQuery2.queryData,
+  searchData: import_dataQuery2.searchData,
+  sortData: import_dataQuery2.sortData,
+  createUpdate: import_createUpdate2.createUpdate,
+  getAttributes: import_attributes2.getAttributes,
+  setAttributeNames: import_attributes2.setAttributeNames,
+  getAttributeNames: import_attributes2.getAttributeNames,
+  // safeParse,
+  processOperators: import_operators2.processOperators,
+  processOperatorsAsync: import_operators2.processOperatorsAsync
+};
+var index_default = utils;

package/dist/cjs/init-browser.js

@@ -0,0 +1,4 @@
+var import_clickedElement = require("./clickedElement.js");
+if (typeof window !== "undefined" && typeof document !== "undefined") {
+  (0, import_clickedElement.clickedElement)();
+}