@contena/meteor-component-library 5.5.0

package/dist/channel-eb1529aa.mjs

@@ -0,0 +1,1535 @@
+import { i as isObjectLike, b as baseGetTag, a as isArray, M as MapCache, S as Symbol$1, c as isLength, d as isIndex, e as isArguments, C as Criteria, f as cloneDeep, h as baseClone, j as isObject$1, k as assignValue } from "./useRepository-dfff5b4a.mjs";
+var objectProto = Object.prototype;
+var hasOwnProperty$1 = objectProto.hasOwnProperty;
+function baseHas(object, key) {
+  return object != null && hasOwnProperty$1.call(object, key);
+}
+var symbolTag = "[object Symbol]";
+function isSymbol(value) {
+  return typeof value == "symbol" || isObjectLike(value) && baseGetTag(value) == symbolTag;
+}
+var reIsDeepProp = /\.|\[(?:[^[\]]*|(["'])(?:(?!\1)[^\\]|\\.)*?\1)\]/, reIsPlainProp = /^\w*$/;
+function isKey(value, object) {
+  if (isArray(value)) {
+    return false;
+  }
+  var type = typeof value;
+  if (type == "number" || type == "symbol" || type == "boolean" || value == null || isSymbol(value)) {
+    return true;
+  }
+  return reIsPlainProp.test(value) || !reIsDeepProp.test(value) || object != null && value in Object(object);
+}
+var FUNC_ERROR_TEXT = "Expected a function";
+function memoize(func, resolver) {
+  if (typeof func != "function" || resolver != null && typeof resolver != "function") {
+    throw new TypeError(FUNC_ERROR_TEXT);
+  }
+  var memoized = function() {
+    var args = arguments, key = resolver ? resolver.apply(this, args) : args[0], cache = memoized.cache;
+    if (cache.has(key)) {
+      return cache.get(key);
+    }
+    var result = func.apply(this, args);
+    memoized.cache = cache.set(key, result) || cache;
+    return result;
+  };
+  memoized.cache = new (memoize.Cache || MapCache)();
+  return memoized;
+}
+memoize.Cache = MapCache;
+var MAX_MEMOIZE_SIZE = 500;
+function memoizeCapped(func) {
+  var result = memoize(func, function(key) {
+    if (cache.size === MAX_MEMOIZE_SIZE) {
+      cache.clear();
+    }
+    return key;
+  });
+  var cache = result.cache;
+  return result;
+}
+var rePropName = /[^.[\]]+|\[(?:(-?\d+(?:\.\d+)?)|(["'])((?:(?!\2)[^\\]|\\.)*?)\2)\]|(?=(?:\.|\[\])(?:\.|\[\]|$))/g;
+var reEscapeChar = /\\(\\)?/g;
+var stringToPath = memoizeCapped(function(string) {
+  var result = [];
+  if (string.charCodeAt(0) === 46) {
+    result.push("");
+  }
+  string.replace(rePropName, function(match, number, quote, subString) {
+    result.push(quote ? subString.replace(reEscapeChar, "$1") : number || match);
+  });
+  return result;
+});
+const stringToPath$1 = stringToPath;
+function arrayMap(array, iteratee) {
+  var index = -1, length = array == null ? 0 : array.length, result = Array(length);
+  while (++index < length) {
+    result[index] = iteratee(array[index], index, array);
+  }
+  return result;
+}
+var INFINITY$1 = 1 / 0;
+var symbolProto = Symbol$1 ? Symbol$1.prototype : void 0, symbolToString = symbolProto ? symbolProto.toString : void 0;
+function baseToString(value) {
+  if (typeof value == "string") {
+    return value;
+  }
+  if (isArray(value)) {
+    return arrayMap(value, baseToString) + "";
+  }
+  if (isSymbol(value)) {
+    return symbolToString ? symbolToString.call(value) : "";
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -INFINITY$1 ? "-0" : result;
+}
+function toString(value) {
+  return value == null ? "" : baseToString(value);
+}
+function castPath(value, object) {
+  if (isArray(value)) {
+    return value;
+  }
+  return isKey(value, object) ? [value] : stringToPath$1(toString(value));
+}
+var INFINITY = 1 / 0;
+function toKey(value) {
+  if (typeof value == "string" || isSymbol(value)) {
+    return value;
+  }
+  var result = value + "";
+  return result == "0" && 1 / value == -INFINITY ? "-0" : result;
+}
+function hasPath(object, path, hasFunc) {
+  path = castPath(path, object);
+  var index = -1, length = path.length, result = false;
+  while (++index < length) {
+    var key = toKey(path[index]);
+    if (!(result = object != null && hasFunc(object, key))) {
+      break;
+    }
+    object = object[key];
+  }
+  if (result || ++index != length) {
+    return result;
+  }
+  length = object == null ? 0 : object.length;
+  return !!length && isLength(length) && isIndex(key, length) && (isArray(object) || isArguments(object));
+}
+function has(object, path) {
+  return object != null && hasPath(object, path, baseHas);
+}
+function generateUniqueId() {
+  return String(Date.now().toString(36) + Math.random().toString(36).substr(2));
+}
+function isObject(value) {
+  return value !== null && typeof value === "object";
+}
+function getWindowSrc() {
+  const location = window.location;
+  const urlObject = new URL(location.pathname, location.origin);
+  return urlObject.toString();
+}
+function hasType(type, obj) {
+  return isObject(obj) && obj.__type__ && obj.__type__ === type;
+}
+function hasOwnProperty(obj, path) {
+  return has(obj, path);
+}
+function traverseObject(traversableObject, processor, previousKey = "root") {
+  for (let index in traversableObject) {
+    const currentEntry = traversableObject[index];
+    processor.apply(this, [traversableObject, index, currentEntry, previousKey]);
+    if (isObject(currentEntry)) {
+      let pk = previousKey + "." + index;
+      traverseObject(currentEntry, processor, pk);
+    }
+  }
+}
+function isPrimitive(value) {
+  return value !== Object(value) || value === null || value === void 0;
+}
+function removeRoot(path) {
+  if (typeof path !== "string") {
+    return path;
+  }
+  return path.replace(/^root\./, "");
+}
+function findExtensionByBaseUrl(baseUrl) {
+  if (typeof baseUrl !== "string") {
+    return void 0;
+  }
+  if (baseUrl === "") {
+    return void 0;
+  }
+  const comparedBaseUrl = new URL(baseUrl);
+  if (comparedBaseUrl.origin === window.location.origin) {
+    return {
+      baseUrl: comparedBaseUrl.hostname,
+      permissions: {
+        additional: ["*"],
+        create: ["*"],
+        read: ["*"],
+        update: ["*"],
+        delete: ["*"]
+      }
+    };
+  }
+  return Object.values(window._swsdk.adminExtensions).find((ext) => {
+    const extensionBaseUrl = new URL(ext.baseUrl);
+    return extensionBaseUrl.hostname === comparedBaseUrl.hostname;
+  });
+}
+class MissingPrivilegesError extends Error {
+  constructor(messageType, missingPrivileges) {
+    super(`Your app is missing the privileges ${missingPrivileges.join(", ")} for action "${messageType}".`);
+    Object.defineProperty(this, "missingPrivileges", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "messageType", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.missingPrivileges = missingPrivileges;
+    this.messageType = messageType;
+    Object.setPrototypeOf(this, MissingPrivilegesError.prototype);
+  }
+  toJSON() {
+    return {
+      __type__: "__MissingPrivilegesError__",
+      __messageType__: this.messageType,
+      __data__: this.missingPrivileges
+    };
+  }
+}
+var __awaiter$1 = globalThis && globalThis.__awaiter || function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+const FunctionSerializerFactory = ({ send: send2, handle: handle2 }) => {
+  const methodRegistry = {};
+  let isMethodHandlerStarted = false;
+  function startMethodHandler() {
+    if (isMethodHandlerStarted)
+      return;
+    isMethodHandlerStarted = true;
+    handle2("__function__", ({ args, id }) => __awaiter$1(this, void 0, void 0, function* () {
+      return yield Promise.resolve(methodRegistry[id](...args));
+    }));
+  }
+  return {
+    name: "function",
+    serialize: ({ value }) => {
+      if (typeof value === "function") {
+        const id = generateUniqueId();
+        methodRegistry[id] = value;
+        startMethodHandler();
+        return {
+          __type__: "__function__",
+          id,
+          origin: window.origin
+        };
+      }
+    },
+    deserialize: ({ value, event }) => {
+      var _a;
+      const targetWindow = (_a = event === null || event === void 0 ? void 0 : event.source) !== null && _a !== void 0 ? _a : window;
+      if (isObject(value) && value["__type__"] && value["__type__"] === "__function__" && typeof value["id"] === "string") {
+        const id = value["id"];
+        const origin = value["origin"];
+        return (...args) => {
+          return send2("__function__", {
+            args,
+            id
+          }, targetWindow, origin);
+        };
+      }
+    }
+  };
+};
+const CriteriaSerializer = () => ({
+  name: "criteria",
+  serialize: ({ value, customizerMethod, seen, path }) => {
+    if (value instanceof Criteria) {
+      return {
+        __type__: "__Criteria__",
+        data: customizerMethod(value.getCriteriaData(), seen, path)
+      };
+    }
+  },
+  deserialize: ({ value, customizerMethod }) => {
+    if (hasType("__Criteria__", value) && typeof value["data"] === "object") {
+      const serializedData = value.data;
+      const deserializedCriteria = new Criteria();
+      deserializedCriteria.setPage(serializedData.page);
+      deserializedCriteria.setLimit(serializedData.limit);
+      deserializedCriteria.setTerm(serializedData.term);
+      if (serializedData.title !== null) {
+        deserializedCriteria.setTitle(serializedData.title);
+      }
+      serializedData.filters.forEach((filter) => {
+        deserializedCriteria.addFilter(filter);
+      });
+      deserializedCriteria.setIds(serializedData.ids);
+      serializedData.queries.forEach(({ query, score }) => {
+        deserializedCriteria.addQuery(query, score);
+      });
+      serializedData.associations.forEach((association) => {
+        deserializedCriteria.associations.push(customizerMethod(association));
+      });
+      serializedData.postFilter.forEach((filter) => {
+        deserializedCriteria.addPostFilter(filter);
+      });
+      serializedData.sortings.forEach((sorting) => {
+        deserializedCriteria.addSorting(sorting);
+      });
+      serializedData.aggregations.forEach((aggregation) => {
+        deserializedCriteria.addAggregation(aggregation);
+      });
+      serializedData.grouping.forEach((group) => {
+        deserializedCriteria.addGrouping(group);
+      });
+      serializedData.fields.forEach((field) => {
+        deserializedCriteria.addFields(field);
+      });
+      serializedData.groupFields.forEach((groupField) => {
+        deserializedCriteria.addGroupField(groupField);
+      });
+      if (serializedData.includes) {
+        deserializedCriteria.addIncludes(serializedData.includes);
+      }
+      deserializedCriteria.setTotalCountMode(serializedData.totalCountMode);
+      return deserializedCriteria;
+    }
+  }
+});
+let setterMethod = (draft, property, value) => {
+  draft[property] = value;
+};
+class EntityClass {
+  constructor(id, entityName, data, options = {}) {
+    var _a, _b;
+    Object.defineProperty(this, "id", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_origin", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_entityName", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_draft", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_isDirty", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "_isNew", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.id = id;
+    this._origin = options.originData ? cloneDeep(options.originData) : cloneDeep(data);
+    this._entityName = entityName;
+    this._draft = data;
+    this._isDirty = (_a = options.isDirty) !== null && _a !== void 0 ? _a : false;
+    this._isNew = (_b = options.isNew) !== null && _b !== void 0 ? _b : false;
+    const that = this;
+    return new Proxy(this._draft, {
+      get(_, property) {
+        if (property in that._draft) {
+          return that._draft[property];
+        }
+        return that[property];
+      },
+      set(_, property, value) {
+        setterMethod(that._draft, property, value);
+        that._isDirty = true;
+        return true;
+      }
+    });
+  }
+  /**
+   * Identifier method for the entity class. Needed when some reactive data layer (Vue) converts the EntityClass to a
+   * plain object. With this identifier method we can (de)serialie it back to the correct entity class.
+   */
+  __identifier__() {
+    return "Entity";
+  }
+  /**
+   * Marks the entity as new. New entities will be provided as create request to the server
+   */
+  markAsNew() {
+    this._isNew = true;
+  }
+  /**
+   * Allows to check if the entity is a new entity and should be provided as create request to the server
+   */
+  isNew() {
+    return this._isNew;
+  }
+  /**
+   * Allows to check if the entity changed
+   */
+  getIsDirty() {
+    return this._isDirty;
+  }
+  /**
+   * Allows access the origin entity value. The origin value contains the server values
+   */
+  getOrigin() {
+    return this._origin;
+  }
+  /**
+   * Allows to access the draft value. The draft value contains all local changes of the entity
+   */
+  getDraft() {
+    return this._draft;
+  }
+  /**
+   * Allows to access the entity name. The entity name is used as unique identifier `product`, `media`, ...
+   */
+  getEntityName() {
+    return this._entityName;
+  }
+}
+const Entity = function Entity2(id, entityName, data, options) {
+  return new EntityClass(id, entityName, data, options);
+};
+const EntitySerializerFactory = () => ({
+  name: "entity",
+  serialize: ({ value, customizerMethod, seen, path }) => {
+    if (!isObject(value) || typeof value.__identifier__ !== "function" || value.__identifier__() !== "Entity") {
+      return;
+    }
+    return {
+      __type__: "__Entity__",
+      __id__: value.id,
+      __entityName__: value._entityName,
+      __isDirty__: value._isDirty,
+      __isNew__: value._isNew,
+      __origin__: customizerMethod(value._origin, seen, path),
+      __draft__: customizerMethod(value._draft, seen, path)
+    };
+  },
+  deserialize: ({ value, customizerMethod }) => {
+    if (hasType("__Entity__", value) && typeof value.__origin__ === "object") {
+      return new Entity(value.__id__, value.__entityName__, customizerMethod(value.__draft__), {
+        originData: customizerMethod(value.__origin__),
+        isDirty: value.__isDirty__,
+        isNew: value.__isNew__
+      });
+    }
+  }
+});
+class EntityCollection extends Array {
+  constructor(source, entityName, context, criteria = null, entities = [], total = null, aggregations = null) {
+    super();
+    Object.defineProperty(this, "entity", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "source", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "context", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "criteria", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "aggregations", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "total", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "first", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "last", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "remove", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "has", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "get", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "getAt", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "getIds", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "add", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "addAt", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "moveItem", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    Object.defineProperty(this, "__identifier__", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: void 0
+    });
+    this.entity = entityName;
+    this.source = source;
+    this.context = context;
+    this.criteria = criteria;
+    this.aggregations = aggregations;
+    this.total = total;
+    this.push(...entities);
+    this.__identifier__ = () => {
+      return "EntityCollection";
+    };
+    this.first = function firstEntityOfCollection() {
+      if (this.length <= 0) {
+        return null;
+      }
+      return this[0];
+    };
+    this.last = function lastEntityOfCollection() {
+      if (this.length <= 0) {
+        return null;
+      }
+      return this[this.length - 1];
+    };
+    this.remove = function removeEntityFromCollection(id) {
+      const itemIndex = this.findIndex((i) => i.id === id);
+      if (itemIndex < 0) {
+        return false;
+      }
+      this.splice(itemIndex, 1);
+      return true;
+    };
+    this.has = function hasEntityInCollection(id) {
+      return this.some((i) => i.id === id);
+    };
+    this.get = function getEntityByIdOfCollection(id) {
+      const item = this.find((i) => i.id === id);
+      if (typeof item !== "undefined") {
+        return item;
+      }
+      return null;
+    };
+    this.getAt = function getEntityAtIndexOfCollection(index) {
+      const item = this[index];
+      if (typeof item !== "undefined") {
+        return item;
+      }
+      return null;
+    };
+    this.getIds = function getEntityIdsOfCollection() {
+      return this.map((i) => i.id);
+    };
+    this.add = function addEntityToCollection(e) {
+      this.push(e);
+    };
+    this.addAt = function addEntityAtIndexOfCollection(e, insertIndex) {
+      if (typeof insertIndex === "undefined") {
+        this.add(e);
+        return;
+      }
+      this.splice(insertIndex, 0, e);
+    };
+    this.moveItem = function moveEntityToNewIndexInCollection(oldIndex, newIndex = null) {
+      if (newIndex === null) {
+        newIndex = this.length;
+      }
+      if (oldIndex < 0 || oldIndex >= this.length) {
+        return null;
+      }
+      if (newIndex === oldIndex) {
+        return this.getAt(oldIndex);
+      }
+      const movedItem = this.find((_, index) => index === oldIndex);
+      if (typeof movedItem === "undefined") {
+        return null;
+      }
+      const remainingItems = this.filter((_, index) => index !== oldIndex);
+      const orderedItems = [
+        ...remainingItems.slice(0, newIndex),
+        movedItem,
+        ...remainingItems.slice(newIndex)
+      ];
+      this.splice(0, this.length, ...orderedItems);
+      return movedItem;
+    };
+    this.filter = function filterEntityCollection(callback, scope) {
+      const filtered = Object.getPrototypeOf(this).filter.call(this, callback, scope);
+      return new EntityCollection(this.source, this.entity, this.context, this.criteria, filtered, this.total, this.aggregations);
+    };
+  }
+  /**
+   * Returns a new collection from given one with
+   */
+  static fromCollection(collection) {
+    return new EntityCollection(collection.source, collection.entity, collection.context, collection.criteria === null ? collection.criteria : Criteria.fromCriteria(collection.criteria), collection, collection.total, collection.aggregations);
+  }
+}
+const EntityCollectionSerializerFactory = () => ({
+  name: "entity-collection",
+  serialize: ({ value, customizerMethod, seen, path }) => {
+    if (value instanceof EntityCollection || (value === null || value === void 0 ? void 0 : value.__identifier__) && value.__identifier__() === "EntityCollection") {
+      return customizerMethod({
+        __type__: "__EntityCollection__",
+        __source__: value.source,
+        __entityName__: value.entity,
+        __context__: value.context,
+        __criteria__: value.criteria,
+        __entities__: Array.from(value),
+        __total__: value.total,
+        __aggregations__: value.aggregations
+      }, seen, path);
+    }
+  },
+  deserialize: ({ value, customizerMethod }) => {
+    if (hasType("__EntityCollection__", value)) {
+      return new EntityCollection(value.__source__, value.__entityName__, value.__context__, customizerMethod(value.__criteria__), customizerMethod(value.__entities__), value.__total__, value.__aggregations__);
+    }
+  }
+});
+class HandleError extends Error {
+  constructor(msg, code) {
+    super(msg);
+    Object.defineProperty(this, "code", {
+      enumerable: true,
+      configurable: true,
+      writable: true,
+      value: 500
+    });
+    if (!code) {
+      return;
+    }
+    this.code = code;
+  }
+  toJSON() {
+    return {
+      __type__: "__HandleError__",
+      __code__: this.code,
+      __message__: this.message
+    };
+  }
+}
+const HandleErrorSerializerFactory = () => ({
+  name: "handle-error",
+  // serialize is empty because the error contains a toJSON function
+  serialize: () => {
+  },
+  deserialize: ({ value }) => {
+    if (hasType("__HandleError__", value)) {
+      return new HandleError(value.__message__, value.__code__);
+    }
+  }
+});
+var CLONE_DEEP_FLAG = 1, CLONE_SYMBOLS_FLAG = 4;
+function cloneDeepWith(value, customizer) {
+  customizer = typeof customizer == "function" ? customizer : void 0;
+  return baseClone(value, CLONE_DEEP_FLAG | CLONE_SYMBOLS_FLAG, customizer);
+}
+function baseGet(object, path) {
+  path = castPath(path, object);
+  var index = 0, length = path.length;
+  while (object != null && index < length) {
+    object = object[toKey(path[index++])];
+  }
+  return index && index == length ? object : void 0;
+}
+function get(object, path, defaultValue) {
+  var result = object == null ? void 0 : baseGet(object, path);
+  return result === void 0 ? defaultValue : result;
+}
+function baseSet(object, path, value, customizer) {
+  if (!isObject$1(object)) {
+    return object;
+  }
+  path = castPath(path, object);
+  var index = -1, length = path.length, lastIndex = length - 1, nested = object;
+  while (nested != null && ++index < length) {
+    var key = toKey(path[index]), newValue = value;
+    if (key === "__proto__" || key === "constructor" || key === "prototype") {
+      return object;
+    }
+    if (index != lastIndex) {
+      var objValue = nested[key];
+      newValue = customizer ? customizer(objValue, key, nested) : void 0;
+      if (newValue === void 0) {
+        newValue = isObject$1(objValue) ? objValue : isIndex(path[index + 1]) ? [] : {};
+      }
+    }
+    assignValue(nested, key, newValue);
+    nested = nested[key];
+  }
+  return object;
+}
+function set(object, path, value) {
+  return object == null ? object : baseSet(object, path, value);
+}
+const MissingPrivilegesErrorSerializer = () => ({
+  name: "handle-error",
+  // serialize is empty because the error contains a toJSON function
+  serialize: () => {
+  },
+  deserialize: ({ value }) => {
+    if (hasType("__MissingPrivilegesError__", value)) {
+      return new MissingPrivilegesError(value.__messageType__, value.__data__);
+    }
+  }
+});
+const serializerFactories = [
+  CriteriaSerializer,
+  EntityCollectionSerializerFactory,
+  EntitySerializerFactory,
+  FunctionSerializerFactory,
+  HandleErrorSerializerFactory,
+  MissingPrivilegesErrorSerializer
+];
+function mainSerializerFactory(dependencies2) {
+  const serializers = serializerFactories.map((serializerFactory) => serializerFactory(dependencies2));
+  function getSerializers() {
+    return serializers;
+  }
+  function getSerializerByName(name2) {
+    var _a;
+    return (_a = serializers.find((serializer) => serializer.name === name2)) !== null && _a !== void 0 ? _a : null;
+  }
+  function serialize2(messageData, seen = /* @__PURE__ */ new Map(), path = "root") {
+    return cloneDeepWith(messageData, (value, key, object, stack) => {
+      let p = path + "." + key;
+      if (isPrimitive(value)) {
+        return value;
+      }
+      if (seen.has(value)) {
+        return {
+          __$CR__: seen.get(value)
+        };
+      }
+      seen.set(value, p);
+      for (const serializer of serializers) {
+        const result = serializer.serialize({
+          value,
+          key,
+          object,
+          stack,
+          customizerMethod: serialize2,
+          seen,
+          path: p
+        });
+        if (result) {
+          return result;
+        }
+      }
+    });
+  }
+  function deserialize2(messageData, event) {
+    const desirialized = _deserialize(messageData, event);
+    traverseObject(desirialized, (_, key, value, previousKey) => {
+      if (key !== "__$CR__") {
+        return;
+      }
+      const path = removeRoot(value);
+      const reference = removeRoot(previousKey);
+      set(desirialized, reference, get(desirialized, path));
+    });
+    return desirialized;
+  }
+  function _deserialize(messageData, event) {
+    return cloneDeepWith(messageData, (value, key, object, stack) => {
+      for (const serializer of serializers) {
+        const result = serializer.deserialize({
+          value,
+          key,
+          object,
+          stack,
+          event,
+          customizerMethod: _deserialize
+        });
+        if (result) {
+          return result;
+        }
+      }
+    });
+  }
+  return {
+    getSerializers,
+    getSerializerByName,
+    serialize: serialize2,
+    deserialize: deserialize2
+  };
+}
+function createError(type, e) {
+  if (typeof e === "string") {
+    return new HandleError(e);
+  }
+  if (!(e instanceof Error)) {
+    return new HandleError("An unknown error occurred.");
+  }
+  if (hasOwnProperty(e, "response.data.errors.0.code") && e.response.data.errors.length) {
+    const missingPrivilegeErrors = e.response.data.errors.filter((error) => error.code === "FRAMEWORK__MISSING_PRIVILEGE_ERROR");
+    const missingPrivileges = [];
+    missingPrivilegeErrors.forEach((mpe) => {
+      const data = JSON.parse(mpe.detail);
+      missingPrivileges.push(...data.missingPrivileges);
+    });
+    if (missingPrivileges.length) {
+      return new MissingPrivilegesError(type, missingPrivileges);
+    }
+    return new HandleError(e.response.data.errors[0].code, e.response.data.errors[0].status);
+  }
+  return new HandleError(e.message);
+}
+function validate({ serializedData, origin, type, privilegesToCheck = [] }) {
+  if (origin === void 0) {
+    return null;
+  }
+  const extension = findExtensionByBaseUrl(origin);
+  if (!extension) {
+    console.warn(`No extension found for origin "${origin}"`);
+    return null;
+  }
+  const privilegeErrors = [];
+  traverseObject(serializedData, (parentEntry, key, value) => {
+    if (key === "__type__" && ["__EntityCollection__", "__Entity__"].includes(value)) {
+      const entityName = parentEntry.__entityName__;
+      if (!entityName) {
+        return;
+      }
+      [...privilegesToCheck].sort().forEach((privilege) => {
+        const permissionsForPrivilege = extension.permissions[privilege];
+        if ((!permissionsForPrivilege || !permissionsForPrivilege.includes(entityName)) && !privilegeErrors.includes(`${privilege}:${entityName}`) && !(permissionsForPrivilege === null || permissionsForPrivilege === void 0 ? void 0 : permissionsForPrivilege.includes("*"))) {
+          privilegeErrors.push(`${privilege}:${entityName}`);
+        }
+      });
+    }
+  });
+  if (privilegeErrors.length > 0) {
+    return new MissingPrivilegesError(type, privilegeErrors);
+  }
+  return null;
+}
+function selectData(sourceData, selectors, messageType = "datasetSubscribe", origin = "") {
+  if (!selectors) {
+    return sourceData;
+  }
+  const result = {};
+  const extension = findExtensionByBaseUrl(origin !== null && origin !== void 0 ? origin : "");
+  const permissionErrors = [];
+  selectors.forEach((selector) => {
+    selectValue(sourceData, selector, extension, permissionErrors, origin, messageType, result);
+  });
+  if (!extension) {
+    console.warn(`No extension found for origin "${origin}"`);
+    return result;
+  }
+  if (permissionErrors.length) {
+    return new MissingPrivilegesError(messageType, permissionErrors);
+  }
+  return result;
+}
+function selectValue(data, selector, extension, permissionErrors, origin, messageType, result = {}) {
+  var _a, _b, _c;
+  const parts = selector.split(".");
+  let tmpResult = result;
+  let tmpData = data;
+  for (let i = 0; i < parts.length; i++) {
+    const specificArrayMatcher = /\[\d*\]/;
+    const currentPart = parts[i];
+    const nextPart = parts[i + 1];
+    if (nextPart && (nextPart === "*" || nextPart.match(specificArrayMatcher))) {
+      if (!parts[i + 2]) {
+        checkPermission(tmpData, extension, permissionErrors);
+        checkPermission(tmpData === null || tmpData === void 0 ? void 0 : tmpData[currentPart], extension, permissionErrors);
+        tmpResult[currentPart] = tmpData === null || tmpData === void 0 ? void 0 : tmpData[currentPart];
+        break;
+      }
+      tmpResult[currentPart] = (_a = tmpResult[currentPart]) !== null && _a !== void 0 ? _a : [];
+      tmpData = tmpData === null || tmpData === void 0 ? void 0 : tmpData[currentPart];
+      tmpResult = tmpResult[currentPart];
+      continue;
+    }
+    if (Array.isArray(tmpData) && nextPart) {
+      const selectorAfterCurrent = parts.slice(i + 1).join(".");
+      if (currentPart === "*") {
+        for (let j = 0; j < tmpData.length; j++) {
+          selectValue(
+            tmpData[j],
+            selectorAfterCurrent,
+            extension,
+            permissionErrors,
+            origin,
+            messageType,
+            // Result is either the root array or the existing array entry
+            (_b = tmpResult[j]) !== null && _b !== void 0 ? _b : tmpResult
+          );
+        }
+        break;
+      }
+      if (currentPart.match(specificArrayMatcher)) {
+        const index = parseArrayIndex(currentPart);
+        selectValue(
+          tmpData[index],
+          selectorAfterCurrent,
+          extension,
+          permissionErrors,
+          origin,
+          messageType,
+          // Result is either the root array or the existing array entry
+          (_c = tmpResult[index]) !== null && _c !== void 0 ? _c : tmpResult
+        );
+        break;
+      }
+    }
+    if (i === parts.length - 1) {
+      checkPermission(tmpData, extension, permissionErrors);
+      checkPermission(tmpData === null || tmpData === void 0 ? void 0 : tmpData[currentPart], extension, permissionErrors);
+      if (Array.isArray(tmpResult)) {
+        tmpResult.push({ [currentPart]: tmpData === null || tmpData === void 0 ? void 0 : tmpData[currentPart] });
+        break;
+      }
+      tmpResult[currentPart] = tmpData === null || tmpData === void 0 ? void 0 : tmpData[currentPart];
+      break;
+    }
+    tmpResult[currentPart] = {};
+    tmpData = tmpData === null || tmpData === void 0 ? void 0 : tmpData[currentPart];
+    tmpResult = tmpResult[currentPart];
+  }
+  return result;
+}
+function checkPermission(data, extension, permissionErrors) {
+  if (!data) {
+    return;
+  }
+  const permissionsToCheck = ["read"];
+  let entityName = "";
+  if (data.__identifier__ && data.__identifier__() === "Entity") {
+    entityName = data.getEntityName();
+  }
+  if (data.__identifier__ && data.__identifier__() === "EntityCollection") {
+    entityName = data.entity;
+  }
+  if (!entityName) {
+    return;
+  }
+  permissionsToCheck.forEach((privilege) => {
+    var _a;
+    const permissionsForPrivilege = (_a = extension === null || extension === void 0 ? void 0 : extension.permissions) === null || _a === void 0 ? void 0 : _a[privilege];
+    if ((!permissionsForPrivilege || !permissionsForPrivilege.includes(entityName)) && !permissionErrors.includes(`${privilege}:${entityName}`) && !(permissionsForPrivilege === null || permissionsForPrivilege === void 0 ? void 0 : permissionsForPrivilege.includes("*"))) {
+      permissionErrors.push(`${privilege}:${entityName}`);
+    }
+  });
+}
+function parseArrayIndex(index) {
+  return Number.parseInt(index.replace("[", "").replace("]", ""));
+}
+const name = "@contena/meteor-admin-sdk";
+const version = "6.11.0";
+const description = "The Meteor SDK for the Contena Administration.";
+const keywords = [
+  "iframe",
+  "contena",
+  "admin",
+  "bridge",
+  "app",
+  "sdk"
+];
+const repository = {
+  type: "git",
+  url: "git+ssh://git@github.com:contena/meteor.git"
+};
+const license = "Apache-2.0";
+const exports = {
+  "./es/channel": {
+    "import": "./es/channel.js",
+    require: "./umd/channel.js"
+  },
+  "./es/data": {
+    "import": "./es/data/index.js",
+    require: "./umd/data/index.js"
+  },
+  "./es/location": {
+    "import": "./es/location/index.js",
+    require: "./umd/location/index.js"
+  },
+  "./es/_internals/privileges/missing-privileges-error": {
+    "import": "./es/_internals/privileges/missing-privileges-error.js",
+    require: "./umd/_internals/privileges/missing-privileges-error.js"
+  },
+  "./es/_internals/data/selectData": {
+    "import": "./es/_internals/data/selectData.js",
+    require: "./umd/_internals/data/selectData.js"
+  },
+  "./es/data/Criteria": {
+    "import": "./es/data/Criteria.js",
+    require: "./umd/data/Criteria.js"
+  },
+  "./es/_internals/data/Entity": {
+    "import": "./es/_internals/data/Entity.js",
+    require: "./umd/_internals/data/Entity.js"
+  },
+  "./es/_internals/data/EntityCollection": {
+    "import": "./es/_internals/data/EntityCollection.js",
+    require: "./umd/_internals/data/EntityCollection.js"
+  },
+  "./es/data/repository": {
+    "import": "./es/data/repository.js",
+    require: "./umd/data/repository.js"
+  },
+  "./es/data/data-table-filter.helper": {
+    "import": "./es/data/data-table-filter.helper.js",
+    require: "./umd/data/data-table-filter.helper.js"
+  },
+  "./es/data/composables": {
+    "import": "./es/data/composables/index.js",
+    require: "./umd/data/composables/index.js"
+  },
+  "./es/data/composables/useSharedState": {
+    "import": "./es/data/composables/useSharedState.js",
+    require: "./umd/data/composables/useSharedState.js"
+  },
+  "./es/data/composables/useRepository": {
+    "import": "./es/data/composables/useRepository.js",
+    require: "./umd/data/composables/useRepository.js"
+  },
+  "./es/data/composables/getRepository": {
+    "import": "./es/data/composables/getRepository.js",
+    require: "./umd/data/composables/getRepository.js"
+  },
+  ".": {
+    "import": "./es/index.js",
+    require: "./umd/index.js"
+  }
+};
+const main = "./umd/index.js";
+const module = "./es/index.js";
+const types = "./es/index.d.ts";
+const files = [
+  "umd",
+  "es",
+  "cdn",
+  "NOTICE",
+  "THIRD-PARTY-LICENSES"
+];
+const scripts = {
+  build: "rm -rf es && rm -rf umd && rm -rf cdn && npm run build:umd && npm run build:es && npm run build:cdn",
+  "build:cdn": "vite build --mode cdn",
+  "build:es": 'tsc --project tsconfig.json --outDir "./es"',
+  "build:umd": 'tsc --project tsconfig.json --module umd --outDir "./umd"',
+  "circular-dependencies": "madge --circular --warning src",
+  "circular-dependencies:image": "madge --circular --warning --image ./dependency-graph.png src",
+  dev: 'concurrently "npm run dev:build-watch" "npm run dev:serve -- --port=8181" "npm run dev:serve -- --port=8182"',
+  "dev:build-watch": "vite build --watch --mode example --emptyOutDir",
+  "dev:serve": "http-server testpageDist --silent",
+  "docs:env": '[ -d "../../../developer-portal" ] && ../../../developer-portal/docs-cli.cjs pull || (git clone git@github.com:contena/developer-portal.git ../../../developer-portal && pnpm i -C ../../../developer-portal)',
+  "docs:link": "../../../developer-portal/docs-cli.cjs link --src ../../docs/admin-sdk --dst resources/admin-extension-sdk --symlink",
+  "docs:preview": "../../../developer-portal/docs-cli.cjs preview",
+  "lint:all": "npm run lint:types && npm run lint:eslint",
+  "lint:eslint": "eslint ./src --ext .ts",
+  "lint:types": "tsc --noEmit",
+  prepublish: "npm run build",
+  "test:e2e": 'concurrently --handle-input --kill-others --success first "npm run dev" "wait-on http://127.0.0.1:8181 && wait-on http://127.0.0.1:8182 && playwright test"',
+  "test:e2e:dev": "playwright test --project=chromium --reporter=list",
+  "test:e2e:dev-debug": "PWDEBUG=1 npm run test:e2e:dev",
+  "test:e2e:dev-watch": `chokidar "{e2e,src}/**/*.{js,ts}" -c 'clear && npm run test:e2e:dev' --initial`,
+  "test:unit": "jest --collectCoverage",
+  "test:unit:watch": "npm run circular-dependencies && jest --watch"
+};
+const dependencies = {
+  "jwt-decode": "^4.0.0",
+  localforage: "^1.10.0",
+  "lodash-es": "^4.17.21",
+  semver: "^7.7.1"
+};
+const devDependencies = {
+  "@playwright/test": "^1.45.0",
+  "@types/jest": "^27.4.1",
+  "@types/lodash-es": "^4.17.12",
+  "@types/node": "^18.11.17",
+  "@typescript-eslint/eslint-plugin": "^5.47.0",
+  "@typescript-eslint/parser": "^8.36.0",
+  "chokidar-cli": "^3.0.0",
+  concurrently: "^7.0.0",
+  eslint: "^8.11.0",
+  "eslint-plugin-check-file": "^2.7.0",
+  "eslint-plugin-import": "^2.31.0",
+  "flush-promises": "^1.0.2",
+  "http-server": "^14.1.0",
+  jest: "^27.5.1",
+  "jest-fail-on-console": "^2.2.3",
+  madge: "^5.0.1",
+  "ts-jest": "^27.1.3",
+  typescript: "^4.9.4",
+  vite: "^2.8.6",
+  "vite-plugin-dts": "^0.9.10",
+  "vite-tsconfig-paths": "^3.4.1",
+  vue: "^2.7.14",
+  "wait-on": "^6.0.1"
+};
+const packageJson = {
+  name,
+  version,
+  description,
+  keywords,
+  repository,
+  license,
+  exports,
+  main,
+  module,
+  types,
+  files,
+  scripts,
+  dependencies,
+  devDependencies
+};
+const sdkVersion = packageJson.version;
+var __awaiter = globalThis && globalThis.__awaiter || function(thisArg, _arguments, P, generator) {
+  function adopt(value) {
+    return value instanceof P ? value : new P(function(resolve) {
+      resolve(value);
+    });
+  }
+  return new (P || (P = Promise))(function(resolve, reject) {
+    function fulfilled(value) {
+      try {
+        step(generator.next(value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function rejected(value) {
+      try {
+        step(generator["throw"](value));
+      } catch (e) {
+        reject(e);
+      }
+    }
+    function step(result) {
+      result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected);
+    }
+    step((generator = generator.apply(thisArg, _arguments || [])).next());
+  });
+};
+const packageVersion = sdkVersion;
+const { serialize, deserialize } = mainSerializerFactory({
+  handle,
+  send
+});
+const adminExtensions = {};
+const sourceRegistry = /* @__PURE__ */ new Set();
+const subscriberRegistry = /* @__PURE__ */ new Set();
+function send(type, data, _targetWindow, _origin) {
+  const callbackId = generateUniqueId();
+  const sendData = data !== null && data !== void 0 ? data : {};
+  const messageData = {
+    _type: type,
+    _data: sendData,
+    _callbackId: callbackId
+  };
+  let serializedData = serialize(messageData);
+  if (_origin) {
+    const validationErrors = validate({
+      serializedData,
+      origin: _origin,
+      privilegesToCheck: ["read"],
+      type
+    });
+    if (validationErrors) {
+      if ([
+        "datasetSubscribe",
+        "datasetUpdate",
+        "datasetRegistration",
+        "datasetGet"
+      ].includes(serializedData._type)) {
+        serializedData = serialize({
+          _type: serializedData._type,
+          _callbackId: serializedData._callbackId,
+          _data: {
+            // @ts-expect-error - We know with the includes that it has an ID
+            // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+            id: serializedData._data.id,
+            data: validationErrors
+          }
+        });
+      } else {
+        serializedData = serialize({
+          _type: serializedData._type,
+          _callbackId: serializedData._callbackId,
+          _data: validationErrors
+        });
+      }
+    }
+  }
+  const message = JSON.stringify(serializedData);
+  let isResolved = false;
+  const timeoutMs = 7e3;
+  return new Promise((resolve, reject) => {
+    const callbackHandler = function(event) {
+      if (typeof event.data !== "string") {
+        return;
+      }
+      if (event.data.indexOf(`"_callbackId":"${callbackId}"`) === -1) {
+        return;
+      }
+      let contenaResponseData;
+      try {
+        contenaResponseData = JSON.parse(event.data);
+      } catch (_a) {
+        return;
+      }
+      if (!isMessageResponseData(contenaResponseData)) {
+        return;
+      }
+      if (!contenaResponseData.hasOwnProperty("_response")) {
+        return;
+      }
+      const deserializedResponseData = deserialize(contenaResponseData, event);
+      window.removeEventListener("message", callbackHandler);
+      if (!isResolved) {
+        isResolved = true;
+        const response = deserializedResponseData._response;
+        if (response instanceof Error) {
+          reject(response);
+          return;
+        }
+        resolve(response);
+      }
+    };
+    window.addEventListener("message", callbackHandler);
+    let corsRestriction = true;
+    try {
+      corsRestriction = !window.parent.origin;
+    } catch (_a) {
+    }
+    let targetOrigin = corsRestriction ? document.referrer : window.parent.origin;
+    if (_origin) {
+      targetOrigin = _origin;
+    }
+    _targetWindow ? _targetWindow.postMessage(message, targetOrigin) : window.parent.postMessage(message, targetOrigin);
+    setTimeout(() => {
+      if (isResolved) {
+        return;
+      }
+      reject("Send timeout expired. It could be possible that no handler for the postMessage request exists or that the handler freezed.");
+    }, timeoutMs);
+  });
+}
+function handle(type, method) {
+  const handleListener = function(event) {
+    var _a;
+    return __awaiter(this, void 0, void 0, function* () {
+      if (typeof event.data !== "string") {
+        return;
+      }
+      if (event.data.indexOf(`"_type":"${type}"`) === -1) {
+        return;
+      }
+      let contenaMessageData;
+      try {
+        contenaMessageData = JSON.parse(event.data);
+      } catch (_b) {
+        return;
+      }
+      if (!isMessageData(contenaMessageData)) {
+        return;
+      }
+      const deserializedMessageData = deserialize(contenaMessageData, event);
+      const responseValue = yield Promise.resolve((() => {
+        const responseValidationTypes = [
+          "datasetSubscribe",
+          "datasetGet",
+          "datasetUpdate",
+          // Test value
+          "_collectionTest"
+        ];
+        if (!responseValidationTypes.includes(type)) {
+          return method(deserializedMessageData._data, { _event_: event });
+        }
+        const validationErrors = validate({
+          serializedData: contenaMessageData,
+          origin: event.origin,
+          type,
+          privilegesToCheck: ["create", "delete", "update", "read"]
+        });
+        if (validationErrors) {
+          return validationErrors;
+        }
+        return method(deserializedMessageData._data, { _event_: event });
+      })()).catch((e) => createError(type, e));
+      const responseMessage = {
+        _callbackId: deserializedMessageData._callbackId,
+        _type: deserializedMessageData._type,
+        _response: responseValue !== null && responseValue !== void 0 ? responseValue : null
+      };
+      const serializedResponseMessage = (() => {
+        let serializedMessage = serialize(responseMessage);
+        const messageValidationTypes = [
+          "datasetSubscribe",
+          "datasetGet",
+          // Test value
+          "_collectionTest"
+        ];
+        if (!messageValidationTypes.includes(type)) {
+          return serializedMessage;
+        }
+        const validationErrors = validate({
+          serializedData: serializedMessage,
+          origin: event.origin,
+          privilegesToCheck: ["read"],
+          type
+        });
+        if (validationErrors) {
+          serializedMessage._response = validationErrors;
+          serializedMessage = serialize(serializedMessage);
+        }
+        return serializedMessage;
+      })();
+      const stringifiedResponseMessage = JSON.stringify(serializedResponseMessage);
+      if (event.source) {
+        event.source.postMessage(stringifiedResponseMessage, {
+          // eslint-disable-next-line @typescript-eslint/no-unsafe-assignment
+          targetOrigin: (_a = event.origin) !== null && _a !== void 0 ? _a : "*"
+        });
+      } else {
+        window.postMessage(stringifiedResponseMessage, window.origin);
+      }
+    });
+  };
+  window.addEventListener("message", handleListener);
+  return () => window.removeEventListener("message", handleListener);
+}
+function subscribe(type, method) {
+  return handle(type, method);
+}
+function createSender(messageType, baseMessageOptions) {
+  return (messageOptions) => {
+    return send(messageType, Object.assign(Object.assign({}, baseMessageOptions), messageOptions));
+  };
+}
+const datasets = /* @__PURE__ */ new Map();
+(() => __awaiter(void 0, void 0, void 0, function* () {
+  if (window.parent !== window) {
+    applyEmbeddedContext();
+  }
+  handle("__registerWindow__", ({ sdkVersion: sdkVersion2 }, additionalOptions) => {
+    let source;
+    let origin;
+    if (additionalOptions._event_.source) {
+      source = additionalOptions._event_.source;
+      origin = additionalOptions._event_.origin;
+    } else {
+      source = window;
+      origin = window.origin;
+    }
+    sourceRegistry.add({
+      source,
+      origin,
+      sdkVersion: sdkVersion2
+    });
+  });
+  handle("datasetSubscribeRegistration", (data, { _event_ }) => {
+    let source;
+    let origin;
+    if (_event_.source) {
+      source = _event_.source;
+      origin = _event_.origin;
+    } else {
+      source = window;
+      origin = window.origin;
+    }
+    subscriberRegistry.add({
+      id: data.id,
+      source,
+      origin,
+      selectors: data.selectors
+    });
+    const dataset = datasets.get(data.id);
+    if (dataset) {
+      const selectedData = selectData(dataset, data.selectors, "datasetSubscribe", origin);
+      if (selectedData instanceof MissingPrivilegesError) {
+        console.error(selectedData);
+        return;
+      }
+      void send("datasetSubscribe", {
+        id: data.id,
+        data: selectedData,
+        selectors: data.selectors
+      }, source, origin);
+    }
+  });
+  yield send("__registerWindow__", {
+    sdkVersion: packageVersion
+  });
+  if (window.parent !== window) {
+    startAutoThemeSync();
+  }
+}))().catch((e) => console.error(e));
+function isThemeValue(value) {
+  return value === "light" || value === "dark";
+}
+function applyTheme(target, theme) {
+  target.dataset.theme = theme;
+  target.style.setProperty("color-scheme", theme);
+}
+function startThemeSync(target) {
+  let hasReceivedUpdate = false;
+  const stop = subscribe("contextTheme", (theme) => {
+    if (!isThemeValue(theme)) {
+      return;
+    }
+    hasReceivedUpdate = true;
+    applyTheme(target, theme);
+  });
+  const initialFetch = send("contextTheme", {}).then((theme) => {
+    if (!hasReceivedUpdate && isThemeValue(theme)) {
+      applyTheme(target, theme);
+    }
+  });
+  return { initialFetch, stop };
+}
+function startAutoThemeSync() {
+  const target = document.documentElement;
+  if (target.dataset.theme) {
+    return () => {
+    };
+  }
+  const { initialFetch, stop } = startThemeSync(target);
+  initialFetch.catch(() => {
+  });
+  return stop;
+}
+function applyEmbeddedContext() {
+  const root = document.documentElement;
+  if (root.dataset.embedded === void 0) {
+    root.dataset.embedded = "";
+  }
+  if (document.getElementById("meteor-admin-sdk-embedded")) {
+    return;
+  }
+  const style = document.createElement("style");
+  style.id = "meteor-admin-sdk-embedded";
+  style.textContent = [
+    "html[data-embedded] { color-scheme: light dark; }",
+    "html[data-embedded] body { background: unset; }"
+  ].join("\n");
+  document.head.appendChild(style);
+}
+window._swsdk = {
+  sourceRegistry,
+  subscriberRegistry,
+  datasets,
+  adminExtensions
+};
+function isMessageData(eventData) {
+  const contenaMessageData = eventData;
+  return !!contenaMessageData._type && !!contenaMessageData._data && !!contenaMessageData._callbackId;
+}
+function isMessageResponseData(eventData) {
+  const contenaMessageData = eventData;
+  return !!contenaMessageData._type && !!contenaMessageData.hasOwnProperty("_response") && !!contenaMessageData._callbackId;
+}
+export {
+  createSender as c,
+  getWindowSrc as g,
+  handle as h,
+  mainSerializerFactory as m,
+  send as s
+};