@spfx-extensions/package 1.4.8 → 1.4.10

package/dist/debug/ClientSideAssets/spfx-extension-core.js

@@ -0,0 +1,2202 @@
+var __create = Object.create;
+var __getProtoOf = Object.getPrototypeOf;
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __toESM = (mod, isNodeMode, target) => {
+  target = mod != null ? __create(__getProtoOf(mod)) : {};
+  const to = isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target;
+  for (let key of __getOwnPropNames(mod))
+    if (!__hasOwnProp.call(to, key))
+      __defProp(to, key, {
+        get: () => mod[key],
+        enumerable: true
+      });
+  return to;
+};
+var __commonJS = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, {
+      get: all[name],
+      enumerable: true,
+      configurable: true,
+      set: (newValue) => all[name] = () => newValue
+    });
+};
+var __esm = (fn, res) => () => (fn && (res = fn(fn = 0)), res);
+
+// src/utilities/constants.ts
+var SPFX_WEBPART_ID = "d6ca1fc2-0591-4c6d-8a25-cae3262c017b";
+var CONFIGURATOR_APP_ID = "45e75137-13c5-4bb2-a2b3-8ab6382682ee";
+var CONFIGURATOR_PAGE_NAME = "SPFxExtensionsConfigurator";
+var CONFIGURATOR_PAGE_URL = `SitePages/${CONFIGURATOR_PAGE_NAME}.aspx`;
+var MANIFEST_NAME = "manifest.txt";
+var APPCOLLECTION_MANIFEST_NAME = "collectionconfig.txt";
+var APP_LOADING = "Loading...";
+var CONFIGURATION_LIST_NAME = "SPFxExtensionsConfiguration";
+var ALLOWEDAPPSLIST_NAME = "SPFxExtensionsWhiteList";
+var SPFX_EXTENSIONS_FOLDER = "SPFxExtensions";
+var WELL_KNOWN_MANIFEST_LOCATION = `/${SPFX_EXTENSIONS_FOLDER}/`;
+var SPFX_EXTENSIONS_DATA_SITE = "SPFxExtensionsData";
+var SPFxExtensionCore = "[SPFxExtensionCore]";
+var EMPTY_APP_MANIFEST = {
+  appDefinitionMap: [],
+  appRelativeEntryPointUrls: [],
+  isESM: true
+};
+var EMPTY_APP_DEF_ITEM_CONFIG = {
+  enabledEverywhere: false,
+  excludedHubIds: [],
+  excludedIds: [],
+  includedHubIds: [],
+  includedIds: []
+};
+var EMPTY_COLLECTION_MANIFEST = {
+  enabledAppCollections: [],
+  urlMap: []
+};
+var EMPTY_GUID = "00000000-0000-0000-0000-000000000000";
+
+// src/core/utility/colors.ts
+function formatter(open, close, replace = open) {
+  return (input) => {
+    const string = "" + input, index = string.indexOf(close, open.length);
+    return ~index ? open + replaceClose(string, close, replace, index) + close : open + string + close;
+  };
+}
+function replaceClose(string, close, replace, index) {
+  let result = "", cursor = 0;
+  do {
+    result += string.substring(cursor, index) + replace;
+    cursor = index + close.length;
+    index = string.indexOf(close, cursor);
+  } while (~index);
+  return result + string.substring(cursor);
+}
+var reset = formatter("\x1B[0m", "\x1B[0m");
+var bold = formatter("\x1B[1m", "\x1B[22m", "\x1B[22m\x1B[1m");
+var dim = formatter("\x1B[2m", "\x1B[22m", "\x1B[22m\x1B[2m");
+var italic = formatter("\x1B[3m", "\x1B[23m");
+var underline = formatter("\x1B[4m", "\x1B[24m");
+var inverse = formatter("\x1B[7m", "\x1B[27m");
+var hidden = formatter("\x1B[8m", "\x1B[28m");
+var strikethrough = formatter("\x1B[9m", "\x1B[29m");
+var black = formatter("\x1B[30m", "\x1B[39m");
+var red = formatter("\x1B[31m", "\x1B[39m");
+var green = formatter("\x1B[32m", "\x1B[39m");
+var yellow = formatter("\x1B[33m", "\x1B[39m");
+var blue = formatter("\x1B[34m", "\x1B[39m");
+var magenta = formatter("\x1B[35m", "\x1B[39m");
+var cyan = formatter("\x1B[36m", "\x1B[39m");
+var white = formatter("\x1B[37m", "\x1B[39m");
+var gray = formatter("\x1B[90m", "\x1B[39m");
+var bgBlack = formatter("\x1B[40m", "\x1B[49m");
+var bgRed = formatter("\x1B[41m", "\x1B[49m");
+var bgGreen = formatter("\x1B[42m", "\x1B[49m");
+var bgYellow = formatter("\x1B[43m", "\x1B[49m");
+var bgBlue = formatter("\x1B[44m", "\x1B[49m");
+var bgMagenta = formatter("\x1B[45m", "\x1B[49m");
+var bgCyan = formatter("\x1B[46m", "\x1B[49m");
+var bgWhite = formatter("\x1B[47m", "\x1B[49m");
+var blackBright = formatter("\x1B[90m", "\x1B[39m");
+var redBright = formatter("\x1B[91m", "\x1B[39m");
+var greenBright = formatter("\x1B[92m", "\x1B[39m");
+var yellowBright = formatter("\x1B[93m", "\x1B[39m");
+var blueBright = formatter("\x1B[94m", "\x1B[39m");
+var magentaBright = formatter("\x1B[95m", "\x1B[39m");
+var cyanBright = formatter("\x1B[96m", "\x1B[39m");
+var whiteBright = formatter("\x1B[97m", "\x1B[39m");
+var bgBlackBright = formatter("\x1B[100m", "\x1B[49m");
+var bgRedBright = formatter("\x1B[101m", "\x1B[49m");
+var bgGreenBright = formatter("\x1B[102m", "\x1B[49m");
+var bgYellowBright = formatter("\x1B[103m", "\x1B[49m");
+var bgBlueBright = formatter("\x1B[104m", "\x1B[49m");
+var bgMagentaBright = formatter("\x1B[105m", "\x1B[49m");
+var bgCyanBright = formatter("\x1B[106m", "\x1B[49m");
+var bgWhiteBright = formatter("\x1B[107m", "\x1B[49m");
+
+// src/core/services/loggingService.ts
+function logGenericCoreError(...args) {
+  console.error(greenBright(SPFxExtensionCore), new Date().toISOString(), ...args);
+}
+function logGenericCoreWarning(...args) {
+  console.warn(greenBright(SPFxExtensionCore), new Date().toISOString(), ...args);
+}
+function logGenericCoreInfo(...args) {
+  console.info(greenBright(SPFxExtensionCore), new Date().toISOString(), ...args);
+}
+function logGenericCoreDebug(...args) {}
+function logInstanceRequestedError(app, e, additionalData) {
+  logGenericCoreError("Error while executing onInstanceRequested for app", app.id, "with name", app.name, additionalData ? `Additional Data: ${additionalData}` : "", e);
+}
+
+// src/utilities/helpers.ts
+function emptyDummy() {
+  logGenericCoreWarning("The app instance event was called before app instance was initialized.");
+  return () => {};
+}
+var currentContext = window.crypto.randomUUID();
+function getCurrentContextId() {
+  return currentContext;
+}
+function getNewContext() {
+  currentContext = window.crypto.randomUUID();
+  return currentContext;
+}
+function extractGUIDFromString(str) {
+  return str.replace("{", "").replace("}", "");
+}
+function cloneObject(obj) {
+  return JSON.parse(JSON.stringify(obj));
+}
+
+// src/core/services/appServices.ts
+function unmountAppInstance(appDef, instanceKey, userCleanupFunc) {
+  const idx = appDef.instances.findIndex((i) => i.key === instanceKey);
+  if (idx > -1) {
+    const splicedInstance = appDef.instances.splice(idx, 1);
+    if (splicedInstance.length < 1)
+      return;
+    const instance = splicedInstance[0];
+    instance.executeListeners("onConfigurationClose", undefined);
+    instance.allEventListeners.splice(0, instance.allEventListeners.length);
+    userCleanupFunc?.();
+  }
+}
+async function unmountInstancesOnContextChange(contextId) {
+  const instancesToUnmount = window.__SPFxExtensions.Apps.filter((a) => !a.isWebPartApp && !a.keepOnContextChange && a.id !== CONFIGURATOR_APP_ID);
+  for (const alreadyRegisteredApp of instancesToUnmount) {
+    logGenericCoreDebug(alreadyRegisteredApp, `---Unmounting on context change`);
+    for (const appInstance of alreadyRegisteredApp.instances.filter((i) => i.contextId !== contextId)) {
+      appInstance.unmount();
+    }
+  }
+}
+function loadAppInstance(foundApp, appInstance) {
+  if (appInstance.hasBeenRequested)
+    return;
+  try {
+    appInstance.hasBeenRequested = true;
+    foundApp.onInstanceRequested(appInstance).then((userCleanupFunc) => {
+      appInstance.unmount = () => {
+        unmountAppInstance(foundApp, appInstance.key, userCleanupFunc);
+      };
+      appInstance.instanceLoadPromiseResolver();
+    }).catch((e) => {
+      logInstanceRequestedError(foundApp, e);
+    });
+  } catch (e) {
+    logInstanceRequestedError(foundApp, e);
+  }
+}
+
+// src/core/services/appDefinitionService.ts
+function executeAppAddedEvents(appDef) {
+  logGenericCoreDebug(`Executing appAdded event for`, appDef.id);
+  window.__SPFxExtensions.AppEventListeners.filter((l) => l.eventName === "appAdded").forEach((listener) => {
+    try {
+      listener.handler(appDef);
+    } catch (e) {
+      logGenericCoreError("Error executing appAdded event", e);
+    }
+  });
+}
+function ensureApp(appId) {
+  let foundApp = window.__SPFxExtensions.Apps.find((a) => a.id === appId);
+  if (!foundApp) {
+    logGenericCoreDebug(`Registering new app`, appId);
+    foundApp = {
+      id: appId,
+      name: APP_LOADING,
+      description: APP_LOADING,
+      isWebPartApp: false,
+      keepOnContextChange: false,
+      autoExecute: false,
+      maxInstances: Infinity,
+      hideAppSelectorWhenAppLoaded: false,
+      hideConfiguratorButton: false,
+      registrationCompleted: false,
+      instances: [],
+      async onInstanceRequested() {
+        return emptyDummy;
+      }
+    };
+    window.__SPFxExtensions.Apps.push(foundApp);
+  }
+  return foundApp;
+}
+function registerAppService() {
+  if (!window.__SPFxExtensions.Apps) {
+    window.__SPFxExtensions.Apps = [];
+  }
+  if (!window.__SPFxExtensions.RegisterApp) {
+    window.__SPFxExtensions.RegisterApp = async (newAppDefinition) => {
+      const appDefinition = ensureApp(newAppDefinition.id);
+      if (appDefinition.registrationCompleted) {
+        return appDefinition;
+      }
+      appDefinition.registrationCompleted = true;
+      appDefinition.name = newAppDefinition.name;
+      appDefinition.description = newAppDefinition.description;
+      appDefinition.isWebPartApp = newAppDefinition.isWebPartApp;
+      appDefinition.keepOnContextChange = newAppDefinition.keepOnContextChange ?? false;
+      appDefinition.autoExecute = newAppDefinition.autoExecute ?? false;
+      appDefinition.maxInstances = newAppDefinition.maxInstances ?? Infinity;
+      appDefinition.hideAppSelectorWhenAppLoaded = newAppDefinition.hideAppSelectorWhenAppLoaded ?? false;
+      appDefinition.hideConfiguratorButton = newAppDefinition.hideConfiguratorButton ?? false;
+      appDefinition.icon = newAppDefinition.icon;
+      appDefinition.onInstanceRequested = newAppDefinition.onInstanceRequested;
+      executeAppAddedEvents(appDefinition);
+      appDefinition.instances.forEach((appInstance) => {
+        loadAppInstance(appDefinition, appInstance);
+      });
+      return appDefinition;
+    };
+  }
+  if (!window.__SPFxExtensions.UnregisterApp) {
+    window.__SPFxExtensions.UnregisterApp = async (appId) => {
+      const appDefinitionIdx = window.__SPFxExtensions.Apps.findIndex((a) => a.id === appId);
+      if (appDefinitionIdx < 0) {
+        return;
+      }
+      const appDefinition = window.__SPFxExtensions.Apps.splice(appDefinitionIdx, 1);
+      if (appDefinition.length < 1) {
+        return;
+      }
+      logGenericCoreDebug(`Unregistering app`, appDefinition[0].id, appDefinition[0].name);
+      appDefinition[0].instances.forEach((appInstance) => {
+        appInstance.unmount();
+      });
+      return appDefinition[0];
+    };
+  }
+}
+
+// src/core/services/appInstanceService.ts
+function registerEventHandlers(appInstance) {
+  const removeInstanceEventListener = (eventListener) => {
+    const idx = appInstance.allEventListeners.findIndex((el) => el.key === eventListener.key);
+    if (idx > -1) {
+      logGenericCoreDebug("Removing event listener", eventListener);
+      appInstance.allEventListeners.splice(idx, 1);
+    }
+  };
+  const addInstanceEventListener = (eventName, callback) => {
+    const eventListener = {
+      key: window.crypto.randomUUID(),
+      eventName,
+      handler: callback
+    };
+    appInstance.allEventListeners.push(eventListener);
+    return () => {
+      removeInstanceEventListener(eventListener);
+    };
+  };
+  const executeInstanceListeners = (eventName, eventData) => {
+    for (const eventListener of appInstance.allEventListeners) {
+      if (eventListener.eventName != eventName)
+        continue;
+      if (eventListener.handler)
+        eventListener.handler(eventData);
+    }
+  };
+  appInstance.addEventListener = addInstanceEventListener;
+  appInstance.executeListeners = executeInstanceListeners;
+}
+function executeInstanceAddedListeners(appDefinition, appInstance) {
+  logGenericCoreDebug(`Executing instanceAdded event for app`, appDefinition.id, "instance", appInstance.key);
+  window.__SPFxExtensions.AppEventListeners.filter((l) => l.eventName === "instanceAdded").forEach((listener) => {
+    try {
+      listener.handler({ app: appDefinition, instance: appInstance });
+    } catch (e) {
+      logGenericCoreError("Error executing instanceAdded event", e);
+    }
+  });
+}
+function createAppInstance(runTimeConfig) {
+  const { promise: instanceLoadPromise, resolve: instanceLoadPromiseResolver } = Promise.withResolvers();
+  const appInstance = {
+    ...runTimeConfig,
+    key: window.crypto.randomUUID(),
+    contextId: getCurrentContextId(),
+    hasBeenRequested: false,
+    unmount: emptyDummy,
+    allEventListeners: [],
+    addEventListener: emptyDummy,
+    executeListeners: emptyDummy,
+    instanceLoadPromise,
+    instanceLoadPromiseResolver
+  };
+  registerEventHandlers(appInstance);
+  return appInstance;
+}
+function registerAppInstanceService() {
+  if (!window.__SPFxExtensions.InstantiateApp) {
+    window.__SPFxExtensions.InstantiateApp = async (appId, runTimeConfig) => {
+      const foundApp = ensureApp(appId);
+      logGenericCoreDebug(`Creating app instance for app`, appId);
+      const appInstance = createAppInstance(runTimeConfig);
+      foundApp.instances.push(appInstance);
+      executeInstanceAddedListeners(foundApp, appInstance);
+      if (foundApp.registrationCompleted) {
+        loadAppInstance(foundApp, appInstance);
+      }
+      return appInstance;
+    };
+  }
+}
+
+// src/utilities/digest.ts
+async function getContentDigest(content, limit = 0) {
+  const encoder = new TextEncoder;
+  const data = encoder.encode(content);
+  const hash = await window.crypto.subtle.digest("SHA-1", data);
+  const hashArray = Array.from(new Uint8Array(hash));
+  const hashHex = hashArray.map((b) => b.toString(16).padStart(2, "0")).join("");
+  return limit > 0 ? hashHex.substring(0, limit) : hashHex;
+}
+
+// node_modules/idb/build/index.js
+var instanceOfAny = (object, constructors) => constructors.some((c) => object instanceof c);
+var idbProxyableTypes;
+var cursorAdvanceMethods;
+function getIdbProxyableTypes() {
+  return idbProxyableTypes || (idbProxyableTypes = [
+    IDBDatabase,
+    IDBObjectStore,
+    IDBIndex,
+    IDBCursor,
+    IDBTransaction
+  ]);
+}
+function getCursorAdvanceMethods() {
+  return cursorAdvanceMethods || (cursorAdvanceMethods = [
+    IDBCursor.prototype.advance,
+    IDBCursor.prototype.continue,
+    IDBCursor.prototype.continuePrimaryKey
+  ]);
+}
+var transactionDoneMap = new WeakMap;
+var transformCache = new WeakMap;
+var reverseTransformCache = new WeakMap;
+function promisifyRequest(request) {
+  const promise = new Promise((resolve, reject) => {
+    const unlisten = () => {
+      request.removeEventListener("success", success);
+      request.removeEventListener("error", error);
+    };
+    const success = () => {
+      resolve(wrap(request.result));
+      unlisten();
+    };
+    const error = () => {
+      reject(request.error);
+      unlisten();
+    };
+    request.addEventListener("success", success);
+    request.addEventListener("error", error);
+  });
+  reverseTransformCache.set(promise, request);
+  return promise;
+}
+function cacheDonePromiseForTransaction(tx) {
+  if (transactionDoneMap.has(tx))
+    return;
+  const done = new Promise((resolve, reject) => {
+    const unlisten = () => {
+      tx.removeEventListener("complete", complete);
+      tx.removeEventListener("error", error);
+      tx.removeEventListener("abort", error);
+    };
+    const complete = () => {
+      resolve();
+      unlisten();
+    };
+    const error = () => {
+      reject(tx.error || new DOMException("AbortError", "AbortError"));
+      unlisten();
+    };
+    tx.addEventListener("complete", complete);
+    tx.addEventListener("error", error);
+    tx.addEventListener("abort", error);
+  });
+  transactionDoneMap.set(tx, done);
+}
+var idbProxyTraps = {
+  get(target, prop, receiver) {
+    if (target instanceof IDBTransaction) {
+      if (prop === "done")
+        return transactionDoneMap.get(target);
+      if (prop === "store") {
+        return receiver.objectStoreNames[1] ? undefined : receiver.objectStore(receiver.objectStoreNames[0]);
+      }
+    }
+    return wrap(target[prop]);
+  },
+  set(target, prop, value) {
+    target[prop] = value;
+    return true;
+  },
+  has(target, prop) {
+    if (target instanceof IDBTransaction && (prop === "done" || prop === "store")) {
+      return true;
+    }
+    return prop in target;
+  }
+};
+function replaceTraps(callback) {
+  idbProxyTraps = callback(idbProxyTraps);
+}
+function wrapFunction(func) {
+  if (getCursorAdvanceMethods().includes(func)) {
+    return function(...args) {
+      func.apply(unwrap(this), args);
+      return wrap(this.request);
+    };
+  }
+  return function(...args) {
+    return wrap(func.apply(unwrap(this), args));
+  };
+}
+function transformCachableValue(value) {
+  if (typeof value === "function")
+    return wrapFunction(value);
+  if (value instanceof IDBTransaction)
+    cacheDonePromiseForTransaction(value);
+  if (instanceOfAny(value, getIdbProxyableTypes()))
+    return new Proxy(value, idbProxyTraps);
+  return value;
+}
+function wrap(value) {
+  if (value instanceof IDBRequest)
+    return promisifyRequest(value);
+  if (transformCache.has(value))
+    return transformCache.get(value);
+  const newValue = transformCachableValue(value);
+  if (newValue !== value) {
+    transformCache.set(value, newValue);
+    reverseTransformCache.set(newValue, value);
+  }
+  return newValue;
+}
+var unwrap = (value) => reverseTransformCache.get(value);
+function openDB(name, version, { blocked, upgrade, blocking, terminated } = {}) {
+  const request = indexedDB.open(name, version);
+  const openPromise = wrap(request);
+  if (upgrade) {
+    request.addEventListener("upgradeneeded", (event) => {
+      upgrade(wrap(request.result), event.oldVersion, event.newVersion, wrap(request.transaction), event);
+    });
+  }
+  if (blocked) {
+    request.addEventListener("blocked", (event) => blocked(event.oldVersion, event.newVersion, event));
+  }
+  openPromise.then((db) => {
+    if (terminated)
+      db.addEventListener("close", () => terminated());
+    if (blocking) {
+      db.addEventListener("versionchange", (event) => blocking(event.oldVersion, event.newVersion, event));
+    }
+  }).catch(() => {});
+  return openPromise;
+}
+function deleteDB(name, { blocked } = {}) {
+  const request = indexedDB.deleteDatabase(name);
+  if (blocked) {
+    request.addEventListener("blocked", (event) => blocked(event.oldVersion, event));
+  }
+  return wrap(request).then(() => {
+    return;
+  });
+}
+var readMethods = ["get", "getKey", "getAll", "getAllKeys", "count"];
+var writeMethods = ["put", "add", "delete", "clear"];
+var cachedMethods = new Map;
+function getMethod(target, prop) {
+  if (!(target instanceof IDBDatabase && !(prop in target) && typeof prop === "string")) {
+    return;
+  }
+  if (cachedMethods.get(prop))
+    return cachedMethods.get(prop);
+  const targetFuncName = prop.replace(/FromIndex$/, "");
+  const useIndex = prop !== targetFuncName;
+  const isWrite = writeMethods.includes(targetFuncName);
+  if (!(targetFuncName in (useIndex ? IDBIndex : IDBObjectStore).prototype) || !(isWrite || readMethods.includes(targetFuncName))) {
+    return;
+  }
+  const method = async function(storeName, ...args) {
+    const tx = this.transaction(storeName, isWrite ? "readwrite" : "readonly");
+    let target2 = tx.store;
+    if (useIndex)
+      target2 = target2.index(args.shift());
+    return (await Promise.all([
+      target2[targetFuncName](...args),
+      isWrite && tx.done
+    ]))[0];
+  };
+  cachedMethods.set(prop, method);
+  return method;
+}
+replaceTraps((oldTraps) => ({
+  ...oldTraps,
+  get: (target, prop, receiver) => getMethod(target, prop) || oldTraps.get(target, prop, receiver),
+  has: (target, prop) => !!getMethod(target, prop) || oldTraps.has(target, prop)
+}));
+var advanceMethodProps = ["continue", "continuePrimaryKey", "advance"];
+var methodMap = {};
+var advanceResults = new WeakMap;
+var ittrProxiedCursorToOriginalProxy = new WeakMap;
+var cursorIteratorTraps = {
+  get(target, prop) {
+    if (!advanceMethodProps.includes(prop))
+      return target[prop];
+    let cachedFunc = methodMap[prop];
+    if (!cachedFunc) {
+      cachedFunc = methodMap[prop] = function(...args) {
+        advanceResults.set(this, ittrProxiedCursorToOriginalProxy.get(this)[prop](...args));
+      };
+    }
+    return cachedFunc;
+  }
+};
+async function* iterate(...args) {
+  let cursor = this;
+  if (!(cursor instanceof IDBCursor)) {
+    cursor = await cursor.openCursor(...args);
+  }
+  if (!cursor)
+    return;
+  cursor = cursor;
+  const proxiedCursor = new Proxy(cursor, cursorIteratorTraps);
+  ittrProxiedCursorToOriginalProxy.set(proxiedCursor, cursor);
+  reverseTransformCache.set(proxiedCursor, unwrap(cursor));
+  while (cursor) {
+    yield proxiedCursor;
+    cursor = await (advanceResults.get(proxiedCursor) || cursor.continue());
+    advanceResults.delete(proxiedCursor);
+  }
+}
+function isIteratorProp(target, prop) {
+  return prop === Symbol.asyncIterator && instanceOfAny(target, [IDBIndex, IDBObjectStore, IDBCursor]) || prop === "iterate" && instanceOfAny(target, [IDBIndex, IDBObjectStore]);
+}
+replaceTraps((oldTraps) => ({
+  ...oldTraps,
+  get(target, prop, receiver) {
+    if (isIteratorProp(target, prop))
+      return iterate;
+    return oldTraps.get(target, prop, receiver);
+  },
+  has(target, prop) {
+    return isIteratorProp(target, prop) || oldTraps.has(target, prop);
+  }
+}));
+
+// src/utilities/debug.ts
+var DEBUG_KEYS = {
+  SPFXEXT: "SPFXEXT_",
+  SPFXEXT_CORE: "SPFXEXT"
+};
+function inDebug() {
+  return Object.keys(localStorage).some((k) => k.indexOf(DEBUG_KEYS.SPFXEXT) > -1 && Number(localStorage[k]) > 0);
+}
+function isFileInDebug(fullUrl) {
+  return fullUrl.hostname.toLowerCase() === "localhost";
+}
+function isAppInDebug(appName) {
+  return Number(localStorage.getItem(`${DEBUG_KEYS.SPFXEXT}${appName}`)) > 0;
+}
+var isInDebug = inDebug();
+
+// src/core/services/coreIdbService.ts
+var StoreNames = {
+  AppFolderManifestCache: "AppFolderManifestCache",
+  AppCollectionManifestCache: "AppCollectionManifestCache",
+  AllowedApps: "AllowedApps",
+  HubSiteData: "HubSiteData",
+  SPFxExtensionConfig: "SPFxExtensionConfig"
+};
+var DBNAME = `${DEBUG_KEYS.SPFXEXT}COREDB`;
+var openDBPromise = openDB(DBNAME, 1, {
+  blocking(_currentVersion, _blockedVersion, _event) {
+    spfxExtensionsCoreDB.close();
+    alert("A new version of this page is ready. Please reload the page.");
+  },
+  async upgrade(database, oldVersion, _newVersion, _transaction, _event) {
+    if (oldVersion === 0) {
+      database.createObjectStore(StoreNames.AppFolderManifestCache, { keyPath: "url" });
+      database.createObjectStore(StoreNames.AppCollectionManifestCache, {
+        keyPath: "url"
+      });
+      database.createObjectStore(StoreNames.AllowedApps, { keyPath: "Id" });
+      database.createObjectStore(StoreNames.HubSiteData, { keyPath: "SiteId" });
+      database.createObjectStore(StoreNames.SPFxExtensionConfig, { keyPath: "Title" });
+    }
+  }
+});
+openDBPromise.catch((err) => {
+  logGenericCoreError("Error opening database for Core, please contact your administrator.");
+  deleteDB(DBNAME).then(() => {
+    window.location.reload();
+  });
+  throw err;
+});
+var spfxExtensionsCoreDB = await openDBPromise;
+function getCacheItemBase(cacheTimeMinutes) {
+  const dateNow = new Date;
+  dateNow.setMinutes(dateNow.getMinutes() + cacheTimeMinutes);
+  const expires = dateNow.toISOString();
+  return {
+    expires
+  };
+}
+async function evictItemsFromStore(storeName, key) {
+  const cachedItems = await spfxExtensionsCoreDB.getAll(storeName);
+  const nowTime = new Date;
+  const cacheToRemove = cachedItems.filter((ci) => {
+    const itemExpires = new Date(ci.expires);
+    return nowTime >= itemExpires;
+  });
+  const toEvict = cacheToRemove.length;
+  if (toEvict > 0) {
+    const tx = spfxExtensionsCoreDB.transaction(storeName, "readwrite");
+    const txStore = tx.objectStore(storeName);
+    cacheToRemove.forEach((u) => txStore.delete(u[key]));
+    await tx.done;
+    logGenericCoreWarning(`Evicted ${toEvict} items from ${storeName} cache.`);
+  }
+  return toEvict;
+}
+async function getAllExtensionConfigFromDB() {
+  await evictItemsFromStore(StoreNames.SPFxExtensionConfig, "Title");
+  return spfxExtensionsCoreDB.getAll(StoreNames.SPFxExtensionConfig);
+}
+async function getExtensionConfigFromDB(title) {
+  await evictItemsFromStore(StoreNames.SPFxExtensionConfig, "Title");
+  return spfxExtensionsCoreDB.get(StoreNames.SPFxExtensionConfig, title);
+}
+async function addOrUpdateExtensionConfig(item, cacheTimeMinutes = 60) {
+  await spfxExtensionsCoreDB.put(StoreNames.SPFxExtensionConfig, {
+    ...item,
+    ...getCacheItemBase(cacheTimeMinutes)
+  });
+}
+function addOrUpdateExtensionConfigs(items, cacheTimeMinutes) {
+  const tx = spfxExtensionsCoreDB.transaction(StoreNames.SPFxExtensionConfig, "readwrite");
+  const txStore = tx.objectStore(StoreNames.SPFxExtensionConfig);
+  items.forEach((u) => txStore.put({ ...u, ...getCacheItemBase(cacheTimeMinutes) }));
+  return tx.done;
+}
+async function getAllAllowedAppsFromDB() {
+  return spfxExtensionsCoreDB.getAll(StoreNames.AllowedApps);
+}
+async function getManifestTXTCacheItem(url) {
+  return spfxExtensionsCoreDB.get(StoreNames.AppFolderManifestCache, url);
+}
+async function getAppsTXTCacheItem(url) {
+  return spfxExtensionsCoreDB.get(StoreNames.AppCollectionManifestCache, url);
+}
+async function getHubData(id) {
+  return spfxExtensionsCoreDB.get(StoreNames.HubSiteData, id);
+}
+async function addOrUpdateHubDataToCache(item, cacheTimeMinutes = 60) {
+  await spfxExtensionsCoreDB.put(StoreNames.HubSiteData, {
+    ...item,
+    ...getCacheItemBase(cacheTimeMinutes)
+  });
+}
+async function addOrUpdateAppsTXTToCache(item, cacheTimeMinutes = 60) {
+  await spfxExtensionsCoreDB.put(StoreNames.AppCollectionManifestCache, {
+    ...item,
+    ...getCacheItemBase(cacheTimeMinutes)
+  });
+}
+async function addOrUpdateManifestTXTToCache(item, cacheTimeMinutes = 60) {
+  await spfxExtensionsCoreDB.put(StoreNames.AppFolderManifestCache, {
+    ...item,
+    ...getCacheItemBase(cacheTimeMinutes)
+  });
+}
+async function addOrUpdateAllowedAppsToCache(items, cacheTimeMinutes = 5) {
+  const baseCache = getCacheItemBase(cacheTimeMinutes);
+  const tx = spfxExtensionsCoreDB.transaction(StoreNames.AllowedApps, "readwrite");
+  const txStore = tx.objectStore(StoreNames.AllowedApps);
+  items.forEach((item) => txStore.put({ ...baseCache, ...item }));
+  return tx.done;
+}
+function removeAppCollectionManifestFromCache(url) {
+  return spfxExtensionsCoreDB.delete(StoreNames.AppCollectionManifestCache, url);
+}
+function removeAppFolderManifestFromCache(url) {
+  return spfxExtensionsCoreDB.delete(StoreNames.AppFolderManifestCache, url);
+}
+async function evictAppCollectionCache() {
+  return evictItemsFromStore(StoreNames.AppCollectionManifestCache, "url");
+}
+async function evictManifestFolderCache() {
+  return evictItemsFromStore(StoreNames.AppFolderManifestCache, "url");
+}
+async function evictAllowedAppsCache() {
+  return evictItemsFromStore(StoreNames.AllowedApps, "Id");
+}
+async function evictHubDataCache() {
+  return evictItemsFromStore(StoreNames.HubSiteData, "SiteId");
+}
+async function evictManifestTXTCache(item) {
+  if (item) {
+    const matchingItem = await getManifestTXTCacheItem(item.url);
+    if (matchingItem) {
+      if (matchingItem.hash !== item.hash) {
+        await removeAppFolderManifestFromCache(item.url);
+        logGenericCoreWarning(`Evicted ${MANIFEST_NAME} ${matchingItem.url} from cache. Because of hash mismatch.`);
+      }
+    }
+  }
+  return evictManifestFolderCache();
+}
+async function evictAppsTXTCache(item) {
+  if (item) {
+    const matchingItem = await getAppsTXTCacheItem(item.url);
+    if (matchingItem) {
+      if (matchingItem.hash !== item.hash) {
+        await removeAppCollectionManifestFromCache(item.url);
+        logGenericCoreWarning(`Evicted ${APPCOLLECTION_MANIFEST_NAME} ${matchingItem.url} from cache. Because of hash mismatch.`);
+      }
+    }
+  }
+  return evictAppCollectionCache();
+}
+async function getManifestTXTFromCache(url) {
+  await evictManifestTXTCache();
+  if (isInDebug) {
+    return;
+  }
+  return getManifestTXTCacheItem(url);
+}
+async function setOrUpdateManifestTXT(retResult, cacheTimeMinutes) {
+  await evictManifestTXTCache(retResult);
+  const foundItem = await getManifestTXTCacheItem(retResult.url);
+  if (foundItem && foundItem.hash === retResult.hash && !isInDebug) {
+    return;
+  }
+  await addOrUpdateManifestTXTToCache(retResult, cacheTimeMinutes);
+}
+async function setOrUpdateAppCollectionTXT(retResult, cacheTimeMinutes) {
+  await evictAppsTXTCache(retResult);
+  const foundItem = await getAppsTXTCacheItem(retResult.url);
+  if (foundItem && foundItem.hash === retResult.hash && !isInDebug) {
+    return;
+  }
+  await addOrUpdateAppsTXTToCache(retResult, cacheTimeMinutes);
+}
+async function getAppCollectionTXTFromCache(url) {
+  await evictAppsTXTCache();
+  if (isInDebug) {
+    return;
+  }
+  return getAppsTXTCacheItem(url);
+}
+
+// src/core/services/digestService.ts
+async function getDigest(webUrl) {
+  const req = await fetch(`${webUrl}/_api/contextinfo`, {
+    method: "POST",
+    headers: {
+      Accept: "application/json;odata=verbose",
+      "Content-Type": "application/json"
+    }
+  });
+  if (req.status === 200) {
+    const data = await req.json();
+    return data.d.GetContextWebInformation.FormDigestValue;
+  } else {
+    logGenericCoreError("Error while getting digest", req.status);
+  }
+  return "";
+}
+
+// src/core/services/appCatalogService.ts
+var appCatalogPromiseResolver = (_data) => {};
+var appCatalogUrlPromise;
+async function getAppCatalogUrlFromAPI(baseUrl = "") {
+  if (appCatalogUrlPromise) {
+    return appCatalogUrlPromise;
+  }
+  appCatalogUrlPromise = new Promise((resolve) => {
+    appCatalogPromiseResolver = resolve;
+  });
+  try {
+    const apiResponse = await fetch(`${baseUrl}/_api/SP_TenantSettings_Current`, {
+      headers: {
+        Accept: "application/json;odata=verbose"
+      }
+    });
+    const responseData = await apiResponse.json();
+    const url = responseData.d.CorporateCatalogUrl;
+    appCatalogPromiseResolver(url);
+  } catch (err) {
+    logGenericCoreError("Error while getting app catalog url. Trying default /sites/appcatalog", err);
+    const fallBackUrl = `${window.location.origin}/sites/appcatalog`;
+    appCatalogPromiseResolver(fallBackUrl);
+  }
+  return appCatalogUrlPromise;
+}
+async function getAppCatalogUrlCached(baseUrl = "") {
+  const appCatalog = await getExtensionConfigFromDB("AppCatalogUrl");
+  if (appCatalog?.Data) {
+    return appCatalog.Data;
+  }
+  const url = await getAppCatalogUrlFromAPI(baseUrl);
+  await addOrUpdateExtensionConfig({ Title: "AppCatalogUrl", Data: url, date: "", expires: "" }, 240);
+  return url;
+}
+async function getAppCatalogDigest(catalogSubWeb = "") {
+  const appCatalogUrl = await getAppCatalogUrlFromAPI();
+  const url = `${appCatalogUrl}${catalogSubWeb ? `/${catalogSubWeb}` : ``}`;
+  return getDigest(url);
+}
+var APP_CATALOG_URL = await getAppCatalogUrlCached();
+var SPFX_EXTENSIONS_SITE_URL = `${APP_CATALOG_URL}/${SPFX_EXTENSIONS_DATA_SITE}`;
+
+// src/core/utility/defaultConfig.ts
+var ConfigurationNames = {
+  Status: "Status",
+  RootCDNLocation: "RootCDNLocation",
+  InterceptHistory: "InterceptHistory",
+  EnableAppWhiteList: "EnableAppWhiteList",
+  AppCatalogUrl: "AppCatalogUrl",
+  AppCatalogWebs: "AppCatalogWebs",
+  ConfiguratorPageData: "ConfiguratorPageData",
+  AppWhiteList: "AppWhiteList",
+  Version: "2025-04-26T18:12:40.559Z"
+};
+var CoreDefaultConfiguration = [
+  {
+    Title: "Status",
+    Data: "Installed"
+  },
+  {
+    Title: "InterceptHistory",
+    Data: "true"
+  },
+  {
+    Title: "EnableAppWhiteList",
+    Data: "false"
+  },
+  {
+    Title: "RootCDNLocation",
+    Data: `/sites/appcatalog/${SPFX_EXTENSIONS_DATA_SITE}`
+  }
+];
+function getCoreDefaultConfiguration(cdnLocationUrl) {
+  const cdnLoc = CoreDefaultConfiguration.find((c) => c.Title === "RootCDNLocation");
+  if (cdnLoc) {
+    cdnLoc.Data = cdnLocationUrl;
+  }
+  return CoreDefaultConfiguration;
+}
+
+// src/core/services/configurationListService.ts
+var MINIMAL_CONFIG_COUNT = Object.keys(ConfigurationNames).length;
+var appCatalogDigest = await getAppCatalogDigest(SPFX_EXTENSIONS_DATA_SITE);
+var configurationListDataPromise;
+async function ensureConfigurationListDataField() {
+  const fieldsUrl = `${SPFX_EXTENSIONS_SITE_URL}/_api/web/lists/GetByTitle('${CONFIGURATION_LIST_NAME}')/fields`;
+  try {
+    const req = await fetch(fieldsUrl, {
+      headers: {
+        Accept: "application/json;odata=verbose"
+      }
+    });
+    if (req.status === 200) {
+      const data = await req.json();
+      const fields = data.d.results;
+      const fieldNames = fields.map((f) => f.InternalName);
+      const titleField = fields.find((f) => f.InternalName === "Title");
+      if (!titleField) {
+        logGenericCoreError("Title field not found.");
+        return;
+      }
+      if (!titleField.EnforceUniqueValues) {
+        const updateFieldReq = await fetch(`${SPFX_EXTENSIONS_SITE_URL}/_api/web/lists/GetByTitle('${CONFIGURATION_LIST_NAME}')/fields('${titleField.Id}')`, {
+          method: "POST",
+          headers: {
+            Accept: "application/json;odata=verbose",
+            "Content-Type": "application/json;odata=verbose",
+            "X-RequestDigest": appCatalogDigest,
+            "X-HTTP-Method": "MERGE",
+            "If-Match": "*"
+          },
+          body: JSON.stringify({
+            __metadata: {
+              type: "SP.Field"
+            },
+            Indexed: true,
+            EnforceUniqueValues: true
+          })
+        });
+        if (updateFieldReq.status === 204) {
+          logGenericCoreInfo("Title field updated successfully.");
+        } else {
+          logGenericCoreError("Unable to update Title field.");
+        }
+      }
+      if (!fieldNames.includes("Data")) {
+        const addFieldReq = await fetch(fieldsUrl, {
+          method: "POST",
+          headers: {
+            Accept: "application/json;odata=verbose",
+            "Content-Type": "application/json;odata=verbose",
+            "X-RequestDigest": appCatalogDigest
+          },
+          body: JSON.stringify({
+            __metadata: {
+              type: "SP.Field"
+            },
+            Title: "Data",
+            FieldTypeKind: 2,
+            Required: true
+          })
+        });
+        if (addFieldReq.status === 201) {
+          logGenericCoreInfo("Data field added successfully.");
+        } else {
+          logGenericCoreError("Unable to add Data field.");
+        }
+      }
+    }
+  } catch (err) {
+    logGenericCoreError("Error while ensuring configuration list data fields.", err);
+  }
+}
+async function ensureConfigurationList() {
+  let newList = false;
+  try {
+    const req = await fetch(`${SPFX_EXTENSIONS_SITE_URL}/_api/web/lists/GetByTitle('${CONFIGURATION_LIST_NAME}')`);
+    newList = req.status === 404;
+    if (newList) {
+      logGenericCoreInfo("Creating configuration list.");
+      const createReq = await fetch(`${SPFX_EXTENSIONS_SITE_URL}/_api/web/lists`, {
+        method: "POST",
+        headers: {
+          Accept: "application/json;odata=verbose",
+          "Content-Type": "application/json;odata=verbose",
+          "X-RequestDigest": appCatalogDigest
+        },
+        body: JSON.stringify({
+          __metadata: {
+            type: "SP.List"
+          },
+          BaseTemplate: 100,
+          Title: "SPFxExtensionsConfiguration",
+          Description: "Configuration list for SPFxExtensions"
+        })
+      });
+      if (createReq.status === 201) {
+        logGenericCoreInfo("Configuration list created successfully.");
+      } else {
+        logGenericCoreError("Unable to create configuration list.");
+      }
+    }
+    await ensureConfigurationListDataField();
+  } catch (err) {
+    logGenericCoreError("Error while ensuring configuration list.", err);
+  }
+  return newList;
+}
+async function getConfigurationListItemsFromAPI() {
+  const requestUrl = `${SPFX_EXTENSIONS_SITE_URL}/_api/web/lists/GetByTitle('${CONFIGURATION_LIST_NAME}')/items?$select=Title,Data`;
+  const config = {
+    headers: {
+      Accept: "application/json;odata=verbose"
+    }
+  };
+  const req = await fetch(requestUrl, {
+    ...config
+  });
+  if (req.status !== 200) {
+    logGenericCoreError("Unable to fetch configuration list items.");
+    return [];
+  }
+  const data = await req.json();
+  const results = data.d.results;
+  return results;
+}
+async function createDefaultListItems() {
+  for (const item of getCoreDefaultConfiguration(SPFX_EXTENSIONS_SITE_URL)) {
+    const addReq = await fetch(`${SPFX_EXTENSIONS_SITE_URL}/_api/web/lists/GetByTitle('${CONFIGURATION_LIST_NAME}')/items`, {
+      method: "POST",
+      headers: {
+        Accept: "application/json;odata=verbose",
+        "Content-Type": "application/json;odata=verbose",
+        "X-RequestDigest": appCatalogDigest
+      },
+      body: JSON.stringify({
+        __metadata: {
+          type: "SP.Data.SPFxExtensionsConfigurationListItem"
+        },
+        ...item
+      })
+    });
+    if (addReq.status === 201) {
+      logGenericCoreInfo(`Item ${item.Title} added successfully.`);
+    } else {
+      logGenericCoreError(`Unable to add item ${item.Title}.`);
+    }
+  }
+}
+function getConfigurationListData(fresh = false) {
+  if (fresh) {
+    return getConfigurationListItemsFromAPI();
+  }
+  if (configurationListDataPromise) {
+    return configurationListDataPromise;
+  }
+  configurationListDataPromise = getConfigurationListDataCached();
+  return configurationListDataPromise;
+}
+async function getConfigurationListDataCached() {
+  let allConfig = await getAllExtensionConfigFromDB();
+  if (allConfig.length < MINIMAL_CONFIG_COUNT) {
+    const isNewList = await ensureConfigurationList();
+    if (isNewList) {
+      await createDefaultListItems();
+    }
+    const allListData = await getConfigurationListItemsFromAPI();
+    await addOrUpdateExtensionConfigs(allListData, 240);
+    allConfig = await getAllExtensionConfigFromDB();
+  }
+  return allConfig;
+}
+
+// src/core/services/configurationWebService.ts
+async function createWeb(webUrl) {
+  const appCatalog = await getAppCatalogUrlFromAPI();
+  const appCatalogDigest2 = await getAppCatalogDigest();
+  const response = await fetch(`${appCatalog}/_api/web/webs/add`, {
+    method: "POST",
+    headers: {
+      Accept: "application/json;odata=nometadata",
+      "Content-Type": "application/json",
+      "X-RequestDigest": appCatalogDigest2
+    },
+    body: JSON.stringify({
+      parameters: {
+        Description: "Site that stores SPFxExtensions Data and global apps",
+        Language: 1033,
+        Title: "SPFxExtensions Data",
+        Url: webUrl,
+        UseSamePermissionsAsParentSite: true,
+        WebTemplate: "STS"
+      }
+    })
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to create SPFxExtensionsData web in ${appCatalog}`);
+  }
+  const data = await response.json();
+  return data;
+}
+async function getWebData() {
+  const appCatalog = await getAppCatalogUrlFromAPI();
+  const appCatalogDigest2 = await getAppCatalogDigest();
+  const response = await fetch(`${appCatalog}/_api/web/webs`, {
+    method: "GET",
+    headers: {
+      Accept: "application/json;odata=nometadata",
+      "X-RequestDigest": appCatalogDigest2
+    }
+  });
+  if (!response.ok) {
+    throw new Error(`Failed to fetch data from ${appCatalog}/_api/web/webs`);
+  }
+  const data = await response.json();
+  return data.value;
+}
+async function getWebDataCached() {
+  const appCatalogWebs = await getExtensionConfigFromDB("AppCatalogWebs");
+  return appCatalogWebs?.Data ?? [];
+}
+var ensureWebDataPromise;
+async function ensureSPFxWeb() {
+  if (ensureWebDataPromise) {
+    return ensureWebDataPromise;
+  }
+  ensureWebDataPromise = ensureWebDataInternal();
+  return ensureWebDataPromise;
+}
+async function ensureWebDataInternal() {
+  const webData = await getWebDataCached();
+  const hasExtensionWeb = webData.some((web) => web.ServerRelativeUrl.endsWith(SPFX_EXTENSIONS_DATA_SITE));
+  if (!hasExtensionWeb) {
+    const apiData = await getWebData();
+    const apiDataHasExtensionWeb = apiData.some((web) => web.ServerRelativeUrl.endsWith(SPFX_EXTENSIONS_DATA_SITE));
+    if (!apiDataHasExtensionWeb) {
+      const result = await createWeb(SPFX_EXTENSIONS_DATA_SITE);
+      apiData.push(result);
+      await addOrUpdateExtensionConfig({ Title: "AppCatalogWebs", Data: apiData, date: "", expires: "" }, 240);
+    }
+    return apiData;
+  }
+  return webData;
+}
+
+// src/core/services/pageService.ts
+var CONFIGURATOR_APP_INSTANCEID = "f3ab710f-2c08-422e-a7ad-5d93eb51e7a3";
+var digest = await getAppCatalogDigest(SPFX_EXTENSIONS_DATA_SITE);
+var acceptHeader = { accept: "application/json" };
+var digestHeader = { "X-RequestDigest": digest };
+var contentType = { "Content-Type": "application/json" };
+async function createFullPage() {
+  const response = await fetch(`${SPFX_EXTENSIONS_SITE_URL}/_api/sitepages/pages`, {
+    headers: {
+      ...acceptHeader,
+      ...digestHeader,
+      ...contentType
+    },
+    body: JSON.stringify({
+      PageLayoutType: "SingleWebPartAppPage",
+      PromotedState: 0
+    }),
+    method: "POST"
+  });
+  const data = await response.json();
+  return data.Id;
+}
+async function getConfiguratorPageData() {
+  const response = await fetch(`${SPFX_EXTENSIONS_SITE_URL}/_api/sitepages/pages/GetByUrl('${CONFIGURATOR_PAGE_URL}')`, {
+    headers: {
+      ...acceptHeader
+    },
+    method: "GET"
+  });
+  if (response.status === 404) {
+    return;
+  }
+  const data = await response.json();
+  return data;
+}
+var layout = [
+  {
+    dataVersion: "1.4",
+    description: "Title Region Description",
+    id: "cbe7b0a9-3504-44dd-a3a3-0e5cacd07788",
+    instanceId: "cbe7b0a9-3504-44dd-a3a3-0e5cacd07788",
+    properties: {
+      authorByline: [],
+      authors: [],
+      layoutType: "FullWidthImage",
+      showPublishDate: false,
+      showTopicHeader: false,
+      textAlignment: "Left",
+      title: "SPFx Extensions Configurator",
+      topicHeader: "",
+      enableGradientEffect: true
+    },
+    reservedHeight: 280,
+    serverProcessedContent: {
+      htmlStrings: {},
+      searchablePlainTexts: {},
+      imageSources: {},
+      links: {}
+    },
+    title: "Title area"
+  }
+];
+var canvas = [
+  {
+    addedFromPersistedData: false,
+    controlType: 3,
+    displayMode: 2,
+    emphasis: {},
+    id: CONFIGURATOR_APP_INSTANCEID,
+    position: {
+      controlIndex: 1,
+      layoutIndex: 1,
+      sectionFactor: 12,
+      sectionIndex: 1,
+      zoneIndex: 1
+    },
+    reservedHeight: 500,
+    reservedWidth: 500,
+    webPartData: {
+      dataVersion: "1.0",
+      description: "Allows you to add a custom developed app",
+      id: SPFX_WEBPART_ID,
+      instanceId: CONFIGURATOR_APP_INSTANCEID,
+      properties: {
+        description: "Select an app to load from the dropdown below",
+        selectedApp: CONFIGURATOR_APP_ID,
+        SPFxExtensionAppConfiguration: undefined
+      },
+      title: "SPFx Extension Loader"
+    },
+    webPartId: SPFX_WEBPART_ID
+  },
+  {
+    controlType: 0,
+    pageSettingsSlice: {
+      isDefaultDescription: true,
+      isDefaultThumbnail: true
+    }
+  }
+];
+var save = {
+  CanvasContent1: `${JSON.stringify(canvas)}`,
+  LayoutWebpartsContent: `${JSON.stringify(layout)}`,
+  Title: CONFIGURATOR_PAGE_NAME
+};
+async function setPageContent(pageId) {
+  await fetch(`${SPFX_EXTENSIONS_SITE_URL}/_api/sitepages/pages(${pageId})/savepage`, {
+    headers: {
+      "Content-Type": "application/json",
+      ...acceptHeader,
+      ...digestHeader
+    },
+    body: JSON.stringify(save),
+    method: "POST"
+  });
+  await fetch(`${SPFX_EXTENSIONS_SITE_URL}/_api/sitepages/pages(${pageId})/publish`, {
+    headers: {
+      ...acceptHeader,
+      ...digestHeader
+    },
+    method: "POST"
+  });
+}
+async function createConfiguratorPage() {
+  const pageId = await createFullPage();
+  await setPageContent(pageId);
+  return getConfiguratorPageData();
+}
+async function getConfiguratorPageDataCached() {
+  const cachedData = await getExtensionConfigFromDB("ConfiguratorPageData");
+  if (cachedData?.Data) {
+    return cachedData.Data;
+  }
+  const apiData = await getConfiguratorPageData();
+  if (apiData) {
+    await addOrUpdateExtensionConfig({ Title: "ConfiguratorPageData", Data: apiData, date: "", expires: "" }, 480);
+  }
+  return apiData;
+}
+async function ensureConfiguratorPage() {
+  const data = await getConfiguratorPageDataCached();
+  if (!data) {
+    return createConfiguratorPage();
+  }
+  if (data.CanvasContent1.indexOf(CONFIGURATOR_APP_INSTANCEID) === -1) {
+    await setPageContent(data.Id);
+    const refreshData = await getConfiguratorPageData();
+    await addOrUpdateExtensionConfig({ Title: "ConfiguratorPageData", Data: refreshData, date: "", expires: "" }, 480);
+    return refreshData;
+  }
+  return data;
+}
+
+// src/core/services/whiteListService.ts
+var digest2 = await getAppCatalogDigest(SPFX_EXTENSIONS_DATA_SITE);
+async function ensureAppWhiteListFields() {
+  const fieldsUrl = `${SPFX_EXTENSIONS_SITE_URL}/_api/web/lists/GetByTitle('${ALLOWEDAPPSLIST_NAME}')/fields`;
+  try {
+    const req = await fetch(fieldsUrl, {
+      headers: {
+        Accept: "application/json;odata=verbose"
+      }
+    });
+    if (req.status === 200) {
+      const data = await req.json();
+      const fields = data.d.results;
+      const fieldNames = fields.map((f) => f.InternalName);
+      if (!fieldNames.some((internalName) => internalName === "EntryPointUrl")) {
+        await ensureMultiLineField(fieldsUrl, "EntryPointUrl", "Full URL to the Entrypoint JS file, if * is specified all entries will be allowed.", true);
+      }
+    }
+  } catch (err) {
+    logGenericCoreError("Error while ensuring list fields.", err);
+  }
+}
+async function ensureMultiLineField(fieldsUrl, fieldInternalName, description, required) {
+  const addFieldReq = await fetch(fieldsUrl, {
+    method: "POST",
+    headers: {
+      Accept: "application/json;odata=verbose",
+      "Content-Type": "application/json;odata=verbose",
+      "X-RequestDigest": digest2
+    },
+    body: JSON.stringify({
+      __metadata: {
+        type: "SP.Field"
+      },
+      Title: fieldInternalName,
+      FieldTypeKind: 3,
+      Required: required,
+      Description: description
+    })
+  });
+  if (addFieldReq.status === 201) {
+    logGenericCoreInfo(fieldInternalName, "field added successfully.");
+  } else {
+    logGenericCoreError(fieldInternalName, "Unable to add field.");
+  }
+}
+async function createAppWhiteList() {
+  try {
+    const req = await fetch(`${SPFX_EXTENSIONS_SITE_URL}/_api/web/lists/GetByTitle('${ALLOWEDAPPSLIST_NAME}')?$select=*`, {
+      method: "GET",
+      headers: {
+        Accept: "application/json;odata=verbose"
+      }
+    });
+    const newList = req.status === 404;
+    if (newList) {
+      logGenericCoreInfo("Creating app white list.");
+      const createReq = await fetch(`${SPFX_EXTENSIONS_SITE_URL}/_api/web/lists`, {
+        method: "POST",
+        headers: {
+          Accept: "application/json;odata=verbose",
+          "Content-Type": "application/json;odata=verbose",
+          "X-RequestDigest": digest2
+        },
+        body: JSON.stringify({
+          __metadata: {
+            type: "SP.List"
+          },
+          BaseTemplate: 100,
+          Title: ALLOWEDAPPSLIST_NAME,
+          Description: "App whitelist for SPFxExtensions"
+        })
+      });
+      if (createReq.status === 201) {
+        logGenericCoreInfo("App whitelist created successfully.");
+        return createReq.json();
+      } else {
+        logGenericCoreError("Unable to create app whitelist.");
+        return;
+      }
+    }
+    await ensureAppWhiteListFields();
+    return req.json();
+  } catch (err) {
+    logGenericCoreError("Error while ensuring app whitelist.", err);
+  }
+  return;
+}
+async function ensureAppWhiteList() {
+  const cachedData = await getExtensionConfigFromDB("AppWhiteList");
+  if (cachedData?.Data) {
+    return cachedData.Data;
+  }
+  const apiData = await createAppWhiteList();
+  if (apiData) {
+    await addOrUpdateExtensionConfig({ Title: "AppWhiteList", Data: apiData, date: "", expires: "" }, 480);
+  }
+  return apiData;
+}
+
+// src/core/services/coreConfigService.ts
+var configurationInitializationPromise;
+async function initializeCoreConfiguration() {
+  if (configurationInitializationPromise) {
+    return configurationInitializationPromise;
+  }
+  configurationInitializationPromise = initializeCoreConfigurationInternal();
+  return configurationInitializationPromise;
+}
+async function initializeCoreConfigurationInternal() {
+  await ensureSPFxWeb();
+  await ensureAppWhiteList();
+  await ensureConfiguratorPage();
+  window.__SPFxExtensions.Utils.ConfiguratorPageUrl = `${SPFX_EXTENSIONS_SITE_URL}/${CONFIGURATOR_PAGE_URL}`;
+}
+async function getCoreConfig(fresh = false) {
+  await initializeCoreConfiguration();
+  return getConfigurationListData(fresh);
+}
+async function getRootCDNLocation() {
+  const coreConfig = await getCoreConfig();
+  const ROOT_CDN_LOCATION = coreConfig.find((c) => c.Title === "RootCDNLocation")?.Data ?? `${SPFX_EXTENSIONS_SITE_URL}`;
+  const ROOT_APPS_LOCATION = `${ROOT_CDN_LOCATION}${WELL_KNOWN_MANIFEST_LOCATION}`;
+  return `${ROOT_APPS_LOCATION}${APPCOLLECTION_MANIFEST_NAME}`;
+}
+
+// src/core/services/browserCache.ts
+async function cleanCacheOnUpgrade() {
+  let coreConfig = await getCoreConfig();
+  const keyParts = [
+    "spfxextensions",
+    "ff36e5d0-f7c7-421d-9e21-0a422626209a"
+  ];
+  if (coreConfig.find((c) => c.Title === "Version")?.Data !== "2025-04-26T18:12:40.559Z") {
+    coreConfig = await getCoreConfig(true);
+    addOrUpdateExtensionConfig({ Title: "Version", Data: "2025-04-26T18:12:40.559Z", date: "", expires: "" }, 240);
+    const allStorages = await caches.keys();
+    let somethingDeleted = false;
+    for (const storageKey of allStorages) {
+      const storage = await caches.open(storageKey);
+      const allKeys = await storage.keys();
+      const allPromises = [];
+      for (const key of allKeys) {
+        const url = key.url.toLowerCase();
+        if (keyParts.some((k) => url.indexOf(k) > -1)) {
+          logGenericCoreDebug("Deleting cache key", key);
+          somethingDeleted = true;
+          allPromises.push(storage.delete(key, { ignoreMethod: true, ignoreSearch: true }));
+        }
+      }
+      await Promise.allSettled(allPromises);
+    }
+    if (somethingDeleted) {
+      window.location.reload();
+    }
+  }
+}
+function GetRandomCacheStringAsync() {
+  return getContentDigest(`${Date.now()}`, 13);
+}
+
+// src/core/services/allowedAppsService.ts
+var AllowedAppsListDataPromise = getAllowedFilesDataCached();
+async function getAllowedFilesDataCached() {
+  try {
+    const evicted = await evictAllowedAppsCache();
+    const cachedData = await getAllAllowedAppsFromDB();
+    if (cachedData.length > 0 && !evicted) {
+      return cachedData;
+    }
+    if (cachedData.length > 0) {
+      logGenericCoreInfo("Cache mismatch, loading allowed apps data...");
+    }
+    const allowedAppsListData = await getAllowedFilesFromApi();
+    await addOrUpdateAllowedAppsToCache(allowedAppsListData, 5);
+    return allowedAppsListData;
+  } catch (err) {
+    logGenericCoreError("Unable to load allowed apps data...", err);
+    return [];
+  }
+}
+async function getAllowedFilesFromApi(fresh = false) {
+  const coreConfig = await getCoreConfig(fresh);
+  const appWhiteListEnabled = coreConfig.find((c) => c.Title === "EnableAppWhiteList")?.Data === "true";
+  if (!appWhiteListEnabled) {
+    return [
+      {
+        Id: 1,
+        Title: "All apps allowed",
+        EntryPointUrl: "*",
+        date: new Date().toISOString(),
+        expires: new Date().toISOString()
+      }
+    ];
+  }
+  return fetchAllowedFilesFromListInternal();
+}
+async function fetchAllowedFilesFromListInternal() {
+  const url = `${SPFX_EXTENSIONS_SITE_URL}/_api/web/lists/getByTitle('${ALLOWEDAPPSLIST_NAME}')/Items?$select=Id,Title,EntryPointUrl&$top=1000`;
+  const allowedAppsListData = await fetchAllowedFilesWithIterate(url);
+  return allowedAppsListData;
+}
+async function fetchAllowedFilesWithIterate(url) {
+  let fetchUrl = url;
+  const allowedAppsListData = [];
+  while (fetchUrl) {
+    const response = await fetch(fetchUrl, {
+      method: "GET",
+      headers: {
+        Accept: "application/json;odata=verbose"
+      }
+    });
+    const json = await response.json();
+    if (json.error) {
+      throw new Error(JSON.stringify(json.error));
+    }
+    allowedAppsListData.push(...json.d.results);
+    fetchUrl = json.d.__next;
+  }
+  return allowedAppsListData;
+}
+function fileIsAllowed(absoluteFileUrl, allowedList) {
+  const allAllowed = allowedList.some((e) => e.EntryPointUrl === "*");
+  if (allAllowed)
+    return true;
+  const fileOriginAndPath = (absoluteFileUrl.origin + absoluteFileUrl.pathname).toLowerCase();
+  return allowedList.some((allowedEntry) => {
+    try {
+      const entryURL = new URL(allowedEntry.EntryPointUrl);
+      const entryOriginAndPath = entryURL.origin + entryURL.pathname;
+      return fileOriginAndPath === entryOriginAndPath.toLowerCase();
+    } catch (err) {
+      logGenericCoreError("Error while parsing allowed entry URL", allowedEntry.EntryPointUrl, err);
+      return false;
+    }
+  });
+}
+async function isFileAllowedToRun(absoluteFileUrl, manifestName, fresh = false) {
+  if (isFileInDebug(absoluteFileUrl))
+    return true;
+  const allowedList = fresh ? await getAllowedFilesFromApi(fresh) : await AllowedAppsListDataPromise;
+  if (!fileIsAllowed(absoluteFileUrl, allowedList)) {
+    logGenericCoreWarning("File", absoluteFileUrl, `is not allowed to be executed. Please add it to whitelist @ ${SPFX_EXTENSIONS_SITE_URL}.`);
+    logGenericCoreWarning(`If you are a developer you can enable this app by adding localStorage item ${DEBUG_KEYS.SPFXEXT}${manifestName} with a number value corresponding to development port of the localhost server.`);
+    return false;
+  }
+  return true;
+}
+
+// src/services/spContextService.ts
+async function getModernContextAsync() {
+  if (window.moduleLoaderPromise) {
+    const result = await window.moduleLoaderPromise;
+    return result?.context;
+  }
+  console.error("Unable to retrieve Modern SP Context...");
+}
+async function getContextInfoAsync() {
+  if (window.moduleLoaderPromise) {
+    const result = await window.moduleLoaderPromise;
+    if (result?.context?.pageContext) {
+      return {
+        contextType: "SPOModernContext",
+        context: result.context.pageContext
+      };
+    }
+    throw "It seems this is a modern page, however it was not possible to retrieve SP Context...";
+  }
+  if (window._spPageContextInfo) {
+    return {
+      contextType: "ClassicContext",
+      context: window._spPageContextInfo
+    };
+  }
+  throw "It was not possible to retrieve SP Context either through modern or through classic means...";
+}
+
+// src/core/services/contextService.ts
+var initialContext = await getContextInfoAsync();
+function getWebId() {
+  return initialContext.contextType === "SPOModernContext" ? initialContext.context.web.id.toString() : extractGUIDFromString(initialContext.context.webId);
+}
+function getWebAbsoluteUrl() {
+  const absoluteUrl = initialContext.contextType === "SPOModernContext" ? initialContext.context.web.absoluteUrl : initialContext.context.webAbsoluteUrl;
+  return absoluteUrl.replace(/\/$/, "");
+}
+function getSiteId() {
+  return initialContext.contextType === "SPOModernContext" ? initialContext.context.site.id.toString() : extractGUIDFromString(initialContext.context.siteId);
+}
+function getSiteAbsoluteUrl() {
+  return initialContext.contextType === "SPOModernContext" ? initialContext.context.site.absoluteUrl : initialContext.context.siteAbsoluteUrl;
+}
+function getHubSiteId() {
+  return (initialContext.contextType === "SPOModernContext" ? initialContext.context.legacyPageContext.hubSiteId?.toString() : initialContext.context.hubSiteId) ?? EMPTY_GUID;
+}
+function getIsHubSite() {
+  return initialContext.contextType === "SPOModernContext" ? initialContext.context.legacyPageContext.isHubSite : initialContext.context.isHubSite;
+}
+
+// src/core/services/txtAppsService.ts
+function validateAppsTXT(manifest) {
+  if (!Array.isArray(manifest.enabledAppCollections)) {
+    throw `${SPFxExtensionCore} ${APPCOLLECTION_MANIFEST_NAME} enabledAppCollections should be an array`;
+  }
+  if (!Array.isArray(manifest.urlMap)) {
+    throw `${SPFxExtensionCore} ${APPCOLLECTION_MANIFEST_NAME} urlMap should be an array`;
+  }
+}
+async function fetchAndCacheAppsTXT(url, name, type, isHubFetch, skipCache = false, cacheTimeMinutes = 60) {
+  let appCollection = EMPTY_COLLECTION_MANIFEST;
+  const fetchLocation = url.toLowerCase();
+  if (!skipCache && !isInDebug) {
+    const cachedManifest = await getAppCollectionTXTFromCache(fetchLocation);
+    if (cachedManifest) {
+      cachedManifest.isHubFetch = isHubFetch;
+      return cachedManifest;
+    }
+  }
+  const fetchUrl = `${fetchLocation}?v=${Date.now()}`;
+  try {
+    logGenericCoreDebug(`Fetching ${APPCOLLECTION_MANIFEST_NAME} from`, fetchUrl);
+    const mnfReq = await fetch(fetchUrl);
+    const result = await mnfReq.text();
+    appCollection = JSON.parse(result);
+  } catch (err) {
+    logGenericCoreWarning(`Unable to fetch ${APPCOLLECTION_MANIFEST_NAME} from`, fetchUrl, err);
+  }
+  try {
+    validateAppsTXT(appCollection);
+  } catch (err) {
+    logGenericCoreError(`Error while parsing ${APPCOLLECTION_MANIFEST_NAME} from`, fetchUrl, err);
+    appCollection = EMPTY_COLLECTION_MANIFEST;
+  }
+  const hash = await getContentDigest(JSON.stringify(appCollection));
+  const baseResult = {
+    name,
+    url: fetchLocation,
+    type,
+    hash
+  };
+  const retResult = { manifest: appCollection, ...baseResult };
+  await setOrUpdateAppCollectionTXT(retResult, isInDebug ? 1 : cacheTimeMinutes);
+  retResult.isHubFetch = isHubFetch;
+  return retResult;
+}
+async function fetchAppCollectionConfigFromAllLocations(siteUrl, webUrl, hubUrl, skipCache = false) {
+  const allAppManifests = [];
+  const rootLocation = await getRootCDNLocation();
+  allAppManifests.push(fetchAndCacheAppsTXT(rootLocation, "apps", "root", true, skipCache));
+  const normalizedSiteUrl = siteUrl + WELL_KNOWN_MANIFEST_LOCATION;
+  allAppManifests.push(fetchAndCacheAppsTXT(`${normalizedSiteUrl}${APPCOLLECTION_MANIFEST_NAME}`, "apps", "site", false, skipCache));
+  if (hubUrl) {
+    const normalizedHubUrl = hubUrl + WELL_KNOWN_MANIFEST_LOCATION;
+    allAppManifests.push(fetchAndCacheAppsTXT(`${normalizedHubUrl}${APPCOLLECTION_MANIFEST_NAME}`, "apps", "site", true, skipCache));
+  }
+  const normalizedWebUrl = webUrl + WELL_KNOWN_MANIFEST_LOCATION;
+  const fullWebUrl = `${normalizedWebUrl}${APPCOLLECTION_MANIFEST_NAME}`;
+  const siteIsWeb = siteUrl.toLowerCase() === webUrl.toLowerCase();
+  const webIsRoot = fullWebUrl.toLowerCase() === rootLocation.toLowerCase();
+  if (!siteIsWeb && !webIsRoot) {
+    allAppManifests.push(fetchAndCacheAppsTXT(fullWebUrl, "apps", "web", false, skipCache));
+  }
+  const manifestResult = await Promise.all(allAppManifests);
+  return manifestResult;
+}
+
+// src/core/services/txtManifestService.ts
+function validateManifestTXT(manifest) {
+  if (Array.isArray(manifest) || typeof manifest !== "object") {
+    throw `${SPFxExtensionCore} App manifest has to be an object.`;
+  }
+  if (!manifest.appRelativeEntryPointUrls) {
+    logGenericCoreError(`Manifest does not have appRelativeEntryPointUrl property.`, manifest);
+    throw `${SPFxExtensionCore} Manifest does not have appRelativeEntryPointUrl property.`;
+  }
+  if (!manifest.appDefinitionMap) {
+    logGenericCoreError(`Manifest does not have enabledApps property.`, manifest);
+    throw `${SPFxExtensionCore} Manifest does not have enabledApps property.`;
+  }
+}
+async function fetchAndCacheManifestTXT(url, name, type, isHubFetch, skipCache = false, cacheTimeMinutes = 60) {
+  let appManifest = { ...EMPTY_APP_MANIFEST };
+  const fetchLocation = url.toLowerCase();
+  if (!skipCache && !isInDebug) {
+    const cachedManifest = await getManifestTXTFromCache(fetchLocation);
+    if (cachedManifest) {
+      cachedManifest.isHubFetch = isHubFetch;
+      return cachedManifest;
+    }
+  }
+  const fetchUrl = `${fetchLocation}?v=${Date.now()}`;
+  try {
+    logGenericCoreDebug(`Fetching ${MANIFEST_NAME} from`, fetchUrl);
+    const mnfReq = await fetch(fetchUrl);
+    const responseText = await mnfReq.text();
+    appManifest = JSON.parse(responseText);
+  } catch (err) {
+    logGenericCoreWarning(`Unable to fetch ${MANIFEST_NAME} from`, fetchUrl, err);
+  }
+  try {
+    validateManifestTXT(appManifest);
+  } catch (err) {
+    logGenericCoreError(`Error while parsing ${MANIFEST_NAME} from`, fetchUrl, err);
+    appManifest = { ...EMPTY_APP_MANIFEST };
+  }
+  const hash = await getContentDigest(JSON.stringify(appManifest));
+  const baseResult = {
+    name,
+    url: fetchLocation,
+    type,
+    hash
+  };
+  const retResult = {
+    manifest: appManifest,
+    ...baseResult
+  };
+  await setOrUpdateManifestTXT(retResult, isInDebug ? 1 : cacheTimeMinutes);
+  retResult.isHubFetch = isHubFetch;
+  return retResult;
+}
+function getManifestTXTLocation(baseUrl, appKey) {
+  const siteLocation = `${baseUrl}${appKey}/${MANIFEST_NAME}`;
+  const lsKey = `${DEBUG_KEYS.SPFXEXT}${appKey}`;
+  const devSitePort = Number(localStorage.getItem(lsKey));
+  if (devSitePort > 0) {
+    const debugLoc = `https://localhost:${devSitePort}/${MANIFEST_NAME}`;
+    logGenericCoreInfo(`<${appKey}> App is in debug mode, loading from`, debugLoc);
+    return debugLoc;
+  }
+  return siteLocation;
+}
+function loadManifestTXT(appCollectionManifests, skipCache = false) {
+  if (appCollectionManifests.length === 0)
+    return [];
+  const manifestTXTPromises = [];
+  for (const appCollectionManifest of appCollectionManifests) {
+    const baseUrl = appCollectionManifest.url.toLowerCase().replace(APPCOLLECTION_MANIFEST_NAME.toLowerCase(), "");
+    for (const appFolderName of appCollectionManifest.manifest.enabledAppCollections) {
+      const manifestLocation = getManifestTXTLocation(baseUrl, appFolderName);
+      manifestTXTPromises.push(fetchAndCacheManifestTXT(manifestLocation, appFolderName, appCollectionManifest.type, appCollectionManifest.isHubFetch ?? false, skipCache));
+    }
+  }
+  return manifestTXTPromises;
+}
+function getManifestTXTFromAllLocations(coreCollection, skipCache = false) {
+  const rootAppsCollectionManifest = coreCollection.filter((app) => app.type === "root");
+  const rootAppPromises = loadManifestTXT(rootAppsCollectionManifest, skipCache);
+  const siteCollectionAppsManifest = coreCollection.filter((app) => app.type === "site");
+  const scAppPromises = loadManifestTXT(siteCollectionAppsManifest, skipCache);
+  const webAppCollectionManifest = coreCollection.filter((app) => app.type === "web");
+  const subsitePromises = loadManifestTXT(webAppCollectionManifest, skipCache);
+  const allManifestsTXT = [
+    ...rootAppPromises,
+    ...scAppPromises,
+    ...subsitePromises
+  ];
+  return allManifestsTXT;
+}
+
+// src/core/services/componentLoaderService.ts
+var isLoaded = false;
+var loadedAssets = [];
+async function importEntryPointsAndExecute(fullJSUrl, originalEntry, manifest) {
+  if (!manifest.isESM) {
+    const foundNonESMAppConfig = manifest.appDefinitionMap.find((a) => a.appId === originalEntry);
+    if (!foundNonESMAppConfig) {
+      const error = `Could not find app configuration item for non-ESM app ${originalEntry}`;
+      logGenericCoreError(error);
+      return [];
+    }
+    const isEnabled = isEntryEnabledInCurrentContext(foundNonESMAppConfig);
+    if (!isEnabled) {
+      logGenericCoreInfo(`App ${originalEntry} is not enabled in current context. Skipping...`);
+      return [];
+    }
+    try {
+      logGenericCoreWarning(`Non-ESM module detected. Make sure to call window.__SPFxExtensions.RegisterApp and window.__SPFxExtensions.InstantiateApp in code.`, fullJSUrl);
+      await import(fullJSUrl);
+    } catch (e) {
+      const error = `Error while importing or executing ${fullJSUrl} ${e}`;
+      logGenericCoreError(error);
+      return [];
+    }
+    return [];
+  } else {
+    try {
+      const appRegistrations = await import(fullJSUrl);
+      const defaultExport = appRegistrations.default;
+      if (!defaultExport) {
+        logGenericCoreError(`No default export found in ${fullJSUrl}, only ESM modules are supported.`);
+        return [];
+      }
+      return executeRegistrations(defaultExport, manifest, fullJSUrl);
+    } catch (e) {
+      logGenericCoreError(`Error while importing or executing`, fullJSUrl, e);
+      return [];
+    }
+  }
+}
+async function parseManifestAndImportEntryPoints(manifestToParse) {
+  const returnPromiseArray = [];
+  const cdnLoc = manifestToParse.url.replace(MANIFEST_NAME, "");
+  logGenericCoreDebug("Parsing", manifestToParse.type, "manifest:", manifestToParse.manifest);
+  for (const entryUrl of manifestToParse.manifest.appRelativeEntryPointUrls) {
+    const ep = entryUrl.replace(/\.\.\/?/g, "./").replace(/^\.\//, "");
+    const fullJSUrl = `${cdnLoc}${ep}`.toLowerCase();
+    logGenericCoreDebug(`EntryPoint JS: `, fullJSUrl);
+    const jsUrl = new URL(fullJSUrl);
+    if (manifestToParse.manifest.cacheString && manifestToParse.manifest.enableCaching) {
+      const cacheString = isAppInDebug(manifestToParse.name) ? `${new Date().getTime()}` : manifestToParse.manifest.cacheString;
+      jsUrl.searchParams.set("v", `${cacheString}`);
+    }
+    const isAllowed = await isFileAllowedToRun(jsUrl, manifestToParse.name);
+    if (!isAllowed) {
+      continue;
+    }
+    const plainUrl = `${jsUrl.origin}${jsUrl.pathname}`;
+    const urlWithCache = `${jsUrl}`;
+    const isScriptLoaded = loadedAssets.includes(plainUrl);
+    if (isScriptLoaded) {
+      logGenericCoreInfo(`EntryPoint already loaded:`, urlWithCache);
+      continue;
+    }
+    loadedAssets.push(plainUrl);
+    returnPromiseArray.push(importEntryPointsAndExecute(urlWithCache, entryUrl, manifestToParse.manifest));
+  }
+  return returnPromiseArray;
+}
+async function loadModernApps(siteUrl, webUrl, hubUrl, contextId, contextChange = false) {
+  if (contextChange) {
+    handleContextChange(contextId);
+  }
+  if (isLoaded)
+    return;
+  isLoaded = true;
+  const coreCollection = await fetchAppCollectionConfigFromAllLocations(siteUrl, webUrl, hubUrl);
+  const allManifestTXTs = getManifestTXTFromAllLocations(coreCollection);
+  window.__SPFxExtensions.Utils.appManifestPromises = allManifestTXTs;
+  window.__SPFxExtensions.Utils.spAppInitializationPromiseResolver();
+  const allManifestTXTsPromises = await Promise.allSettled(allManifestTXTs);
+  const resolvedManifestTXTs = allManifestTXTsPromises.filter((p) => p.status === "fulfilled");
+  const successfullAppRegistrations = [];
+  const resolvedRootAppsManifests = resolvedManifestTXTs.filter((m) => m.value.type === "root");
+  const resolvedSiteAppsManifests = resolvedManifestTXTs.filter((m) => m.value.type === "site");
+  const resolvedWebAppsManifests = resolvedManifestTXTs.filter((m) => m.value.type === "web");
+  for (const rootManifestTXT of resolvedRootAppsManifests) {
+    const rootEntries = await parseManifestAndImportEntryPoints(rootManifestTXT.value);
+    successfullAppRegistrations.push(...rootEntries);
+  }
+  logGenericCoreDebug("Root apps loaded.");
+  for (const siteManifests of resolvedSiteAppsManifests) {
+    const siteEntries = await parseManifestAndImportEntryPoints(siteManifests.value);
+    successfullAppRegistrations.push(...siteEntries);
+  }
+  logGenericCoreDebug("Site apps loaded.");
+  for (const webManifests of resolvedWebAppsManifests) {
+    const webEntries = await parseManifestAndImportEntryPoints(webManifests.value);
+    successfullAppRegistrations.push(...webEntries);
+  }
+  logGenericCoreDebug("SiteWeb apps loaded.");
+  const successfullyRegistered = (await Promise.allSettled(successfullAppRegistrations)).filter((r) => r.status === "fulfilled").flatMap((r) => r.value);
+  await unregisterNonApplicable(successfullyRegistered);
+  window.__SPFxExtensions.AllAppAssetsLoadedResolver();
+  logGenericCoreInfo("SPFx Extensions Core Components Loaded.");
+}
+function handleContextChange(contextId) {
+  isLoaded = false;
+  loadedAssets.splice(0, loadedAssets.length);
+  unmountInstancesOnContextChange(contextId);
+  const { promise: assetPromise, resolve: assetPromiseResolver } = Promise.withResolvers();
+  window.__SPFxExtensions.AllAppAssetsLoadedPromise = assetPromise;
+  window.__SPFxExtensions.AllAppAssetsLoadedResolver = assetPromiseResolver;
+}
+async function unregisterNonApplicable(allExports) {
+  for (const alreadyRegisteredApp of window.__SPFxExtensions.Apps) {
+    const foundApp = allExports.find((a) => a.id === alreadyRegisteredApp.id);
+    if (!foundApp && alreadyRegisteredApp.id !== CONFIGURATOR_APP_ID) {
+      const unregistered = await window.__SPFxExtensions.UnregisterApp(alreadyRegisteredApp.id);
+      if (unregistered) {
+        logGenericCoreWarning(`Unregistered App ${alreadyRegisteredApp.id} (${alreadyRegisteredApp.name}) as it does not belong in this context`);
+      }
+    }
+  }
+}
+async function executeRegistrations(registrations, manifestToParse, fullJSUrl) {
+  if (!Array.isArray(registrations)) {
+    logGenericCoreError(`Default export of entry point should be an array of App definitions. TODO: add documentation url`, fullJSUrl);
+  }
+  const successfullyRegistered = [];
+  for (const appReg of registrations) {
+    if (!appReg.id) {
+      logGenericCoreError(`App definition does not have an id. Make sure that returned array is in proper format. TODO: add documentation url`, fullJSUrl, appReg);
+      continue;
+    }
+    const foundMapItem = manifestToParse.appDefinitionMap.find((a) => a.appId.toLowerCase() === appReg.id.toLowerCase());
+    const notEnabledMSG = `App with id ${appReg.id} (${appReg.name}) is not enabled for current web. Skipping...`;
+    if (!foundMapItem) {
+      logGenericCoreInfo(notEnabledMSG);
+      continue;
+    }
+    const appEnabled = isEntryEnabledInCurrentContext(foundMapItem);
+    if (!appEnabled) {
+      logGenericCoreInfo(notEnabledMSG);
+      continue;
+    }
+    const registeredApp = await window.__SPFxExtensions.RegisterApp(appReg);
+    successfullyRegistered.push(appReg);
+    if (!appReg.isWebPartApp && appReg.autoExecute) {
+      if (registeredApp.instances.length < (appReg.maxInstances ?? Infinity)) {
+        window.__SPFxExtensions.InstantiateApp(appReg.id, {});
+      }
+    }
+  }
+  return successfullyRegistered;
+}
+function isEntryEnabledInCurrentContext(foundMapItem) {
+  const currentWebId = getWebId().toLowerCase();
+  const currentSiteId = getSiteId().toLowerCase();
+  const currentHubId = getHubSiteId().toLowerCase();
+  const isEnabledEverywhere = foundMapItem.config.enabledEverywhere;
+  const appEnabled = isEnabledEverywhere ? foundMapItem.config.excludedIds.indexOf(currentWebId) === -1 && foundMapItem.config.excludedIds.indexOf(currentSiteId) === -1 && foundMapItem.config.excludedHubIds.indexOf(currentHubId) === -1 : true;
+  return appEnabled;
+}
+
+// src/core/services/contextEventService.ts
+var contextServiceInitialized = false;
+function initializeContextEventService() {
+  if (window.moduleLoaderPromise && !contextServiceInitialized) {
+    contextServiceInitialized = true;
+    window.moduleLoaderPromise.then((ctx) => {
+      const originalInitialize = ctx.context.pageContext.initialize;
+      ctx.context.pageContext.initialize = function(initializationData, legacyContext) {
+        const previousContext = ctx.context.pageContext._initializationData;
+        originalInitialize.call(this, initializationData, legacyContext);
+        const detail = {
+          initializationData,
+          legacyContext
+        };
+        if (previousContext.web.id === initializationData.web.id) {
+          dispatchCoreEvent("contextRefresh", detail);
+          return;
+        }
+        dispatchCoreEvent("contextChange", detail);
+      };
+    });
+  }
+}
+function dispatchCoreEvent(eventName, detail) {
+  const event = new CustomEvent(eventName, {
+    detail
+  });
+  window.dispatchEvent(event);
+  window.__SPFxExtensions.Apps.forEach((app) => {
+    app.instances.forEach((instance) => {
+      instance.executeListeners(eventName, detail);
+    });
+  });
+}
+
+// src/core/services/globalModernAppsListeners.ts
+function registerGlobalListeners() {
+  if (!window.__SPFxExtensions.AppEventListeners) {
+    window.__SPFxExtensions.AppEventListeners = [];
+  }
+  if (!window.__SPFxExtensions.AddAppEventListener) {
+    window.__SPFxExtensions.AddAppEventListener = (ev, handler) => {
+      const el = {
+        key: window.crypto.randomUUID(),
+        eventName: ev,
+        handler
+      };
+      window.__SPFxExtensions.AppEventListeners.push(el);
+      return el;
+    };
+  }
+  if (!window.__SPFxExtensions.RemoveAppEventListener) {
+    window.__SPFxExtensions.RemoveAppEventListener = (listener) => {
+      const lisIdx = window.__SPFxExtensions.AppEventListeners.findIndex((l) => l.key === listener.key);
+      if (lisIdx > -1) {
+        window.__SPFxExtensions.AppEventListeners.splice(lisIdx, 1);
+      }
+    };
+  }
+}
+
+// src/core/services/historyService.ts
+var originalPushState = window.history.pushState;
+var originalReplaceState = window.history.replaceState;
+var originalHistoryBack = window.history.back;
+var originalHistoryForward = window.history.forward;
+var originalHistoryGo = window.history.go;
+function getCurrentState() {
+  const currentState = window.history.state;
+  const previousUrl = window.location.href;
+  return { currentState, previousUrl };
+}
+function dispatchEvent(eventName, newState) {
+  const detail = {
+    ...getCurrentState(),
+    ...newState
+  };
+  const evt = new CustomEvent(eventName, { detail });
+  window.dispatchEvent(evt);
+}
+function interceptHistoryPushState() {
+  function _pushState(newState, unused, newUrl) {
+    originalPushState.call(this, newState, unused, newUrl);
+    dispatchEvent("historyPush", { newState, newUrl });
+  }
+  window.history.pushState = _pushState;
+}
+function interceptHistoryReplaceState() {
+  function _replaceState(newState, unused, newUrl) {
+    originalReplaceState.call(this, newState, unused, newUrl);
+    dispatchEvent("historyReplace", { newState, newUrl });
+  }
+  window.history.replaceState = _replaceState;
+}
+function interceptHistoryBack() {
+  function _goBack() {
+    originalHistoryBack.call(this);
+    dispatchEvent("historyBack", {});
+  }
+  window.history.back = _goBack;
+}
+function interceptHistoryForward() {
+  function _goForward() {
+    originalHistoryForward.call(this);
+    dispatchEvent("historyForward", {});
+  }
+  window.history.forward = _goForward;
+}
+function interceptHistoryGo() {
+  function _go(delta) {
+    originalHistoryGo.call(this, delta);
+    dispatchEvent("historyGo", { delta });
+  }
+  window.history.go = _go;
+}
+var historyInterceptionInited = false;
+function initHistoryInterception() {
+  if (historyInterceptionInited) {
+    return;
+  }
+  historyInterceptionInited = true;
+  interceptHistoryReplaceState();
+  interceptHistoryPushState();
+  interceptHistoryForward();
+  interceptHistoryBack();
+  interceptHistoryGo();
+}
+
+// src/core/services/hubDataService.ts
+async function getHubSiteUrl() {
+  if (getIsHubSite()) {
+    return "";
+  }
+  const hubSiteId = getHubSiteId();
+  const siteId = getSiteId();
+  if (!hubSiteId || hubSiteId === EMPTY_GUID || hubSiteId === siteId) {
+    return "";
+  }
+  await evictHubDataCache();
+  const cached = await getHubData(hubSiteId);
+  if (!cached) {
+    const siteUrl = getSiteAbsoluteUrl();
+    logGenericCoreInfo("Getting Hub data for HubSiteId:", hubSiteId);
+    try {
+      const hubSite = await fetch(`${siteUrl}/_api/hubsites/GetById?hubSiteId='${hubSiteId}'`, {
+        headers: { accept: "application/json;odata=nometadata" }
+      });
+      const hubSiteData = await hubSite.json();
+      await addOrUpdateHubDataToCache(hubSiteData);
+      return hubSiteData.SiteUrl;
+    } catch (e) {
+      logGenericCoreError("Error fetching hub site data.", e);
+      return "";
+    }
+  }
+  return cached.SiteUrl;
+}
+
+// src/core/services/manifestWatcherService.ts
+var CORE_MANIFEST_CHECK = "CORE_MANIFEST_CHECK";
+var CORE_MANIFEST_CHECK_INTERVAL = Number(localStorage.getItem(DEBUG_KEYS.SPFXEXT_CORE)) > 0 ? 1e5 : 60000;
+var manifestWatch = 0;
+function registerManifestWatcher(site, web, hubUrl, contextChange = false) {
+  if (contextChange) {
+    window.clearInterval(manifestWatch);
+    manifestWatch = 0;
+  }
+  if (manifestWatch > 0)
+    return;
+  manifestWatch = window.setInterval(performManifestCheck, CORE_MANIFEST_CHECK_INTERVAL, site, web, hubUrl);
+  performManifestCheck(site, web, hubUrl);
+}
+async function performManifestCheck(site, web, hubUrl) {
+  try {
+    const item = localStorage.getItem(CORE_MANIFEST_CHECK);
+    if (item) {
+      const lastCheck = new Date(item);
+      const now = new Date;
+      const diff = now.getTime() - lastCheck.getTime();
+      const maxDiff = CORE_MANIFEST_CHECK_INTERVAL - 2000;
+      if (diff < maxDiff) {
+        logGenericCoreDebug("Manifest check already performed recently, skipping.", `${diff} < ${maxDiff}`);
+        return;
+      }
+    }
+    logGenericCoreInfo(`Checking for manifest updates across all locations...`);
+    await Promise.all([evictAppsTXTCache(), evictManifestTXTCache()]);
+    const appLocations = await fetchAppCollectionConfigFromAllLocations(site, web, hubUrl, true);
+    const allManifests = getManifestTXTFromAllLocations(appLocations, true);
+    await Promise.allSettled(allManifests);
+  } catch (e) {
+    logGenericCoreError("Error checking for manifest updates", e);
+  }
+  const nextCheck = new Date().toISOString();
+  logGenericCoreDebug("Setting next manifest check to", nextCheck);
+  localStorage.setItem(CORE_MANIFEST_CHECK, nextCheck);
+}
+
+// src/core/services/initializationService.ts
+var coreGlobalPromise;
+async function initGlobal() {
+  if (coreGlobalPromise) {
+    return coreGlobalPromise;
+  }
+  coreGlobalPromise = initGlobalInternal();
+  return coreGlobalPromise;
+}
+async function initGlobalInternal() {
+  await initializeCoreConfiguration();
+  const coreConfig = await getCoreConfig();
+  const historyInterceptEnabled = coreConfig.find((c) => c.Title === "InterceptHistory")?.Data === "true";
+  if (historyInterceptEnabled) {
+    initHistoryInterception();
+  }
+  initializeContextEventService();
+  registerGlobalListeners();
+  registerAppService();
+  registerAppInstanceService();
+  const { promise: assetPromise, resolve: assetPromiseResolver } = Promise.withResolvers();
+  if (!window.__SPFxExtensions.AllAppAssetsLoadedPromise) {
+    window.__SPFxExtensions.AllAppAssetsLoadedPromise = assetPromise;
+    window.__SPFxExtensions.AllAppAssetsLoadedResolver = assetPromiseResolver;
+  }
+}
+async function initCoreServices() {
+  await cleanCacheOnUpgrade();
+  await initGlobal();
+  window.__SPFxExtensions.__CorePromiseResolver?.();
+  const siteUrl = getSiteAbsoluteUrl();
+  const webUrl = getWebAbsoluteUrl();
+  const hubSiteUrl = await getHubSiteUrl();
+  await loadModernApps(siteUrl, webUrl, hubSiteUrl, getCurrentContextId());
+  window.addEventListener("contextChange", async () => {
+    logGenericCoreInfo("Context changed, reloading apps...");
+    const siteUrl2 = getSiteAbsoluteUrl();
+    const webUrl2 = getWebAbsoluteUrl();
+    const hubSiteUrl2 = await getHubSiteUrl();
+    const newCtx = getNewContext();
+    await loadModernApps(siteUrl2, webUrl2, hubSiteUrl2, newCtx, true);
+    registerManifestWatcher(siteUrl2, webUrl2, hubSiteUrl2, true);
+  });
+  registerManifestWatcher(siteUrl, webUrl, hubSiteUrl);
+  logGenericCoreInfo("SPFx Extensions Core Has Been initialized.");
+}
+
+// src/core/__spfxCore.ts
+var configuratorApp = {
+  id: CONFIGURATOR_APP_ID,
+  description: "Allows configuring custom apps",
+  isWebPartApp: false,
+  hideAppSelectorWhenAppLoaded: true,
+  hideConfiguratorButton: true,
+  name: "SPFx Extensions Configurator",
+  async onInstanceRequested(newInstance) {
+    const coreIsInDebug = import.meta.url.indexOf("localhost") > -1;
+    if (coreIsInDebug) {
+      logGenericCoreDebug("Core is in debug mode");
+    }
+    const configuratorUrl = coreIsInDebug ? import.meta.resolve(`./__spfxCoreConfigurator.js?v=${Date.now()}`) : window.__SPFxExtensions.__ConfiguratorUrl;
+    try {
+      const module = await import(configuratorUrl);
+      return module.launch(newInstance);
+    } catch (e) {
+      logGenericCoreError("Error launching configurator app", e);
+      if (newInstance.domElement) {
+        newInstance.domElement.innerHTML = `<div style="text-align: center; padding: 20px; color: red;">Error launching configurator app. ${e}</div>`;
+      }
+      return () => {};
+    }
+  }
+};
+async function start() {
+  const buildDate = "2025-04-26T18:12:40.559Z";
+  logGenericCoreInfo(`Initializing Core Services Built:`, buildDate);
+  await initCoreServices();
+  try {
+    await window.__SPFxExtensions.RegisterApp(configuratorApp);
+  } catch (e) {
+    logGenericCoreError("Error registering configurator app", e);
+  }
+}
+start();