@sparkle-learning/core 0.0.57 → 0.0.59

package/dist/cjs/index-af080b50.js

@@ -0,0 +1,139 @@
+'use strict';
+
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+/**
+ * Does a simple sanitization of all elements
+ * in an untrusted string
+ */
+const sanitizeDOMString = (untrustedString) => {
+  try {
+    if (untrustedString instanceof IonicSafeString) {
+      return untrustedString.value;
+    }
+    if (!isSanitizerEnabled() || typeof untrustedString !== 'string' || untrustedString === '') {
+      return untrustedString;
+    }
+    /**
+     * Create a document fragment
+     * separate from the main DOM,
+     * create a div to do our work in
+     */
+    const documentFragment = document.createDocumentFragment();
+    const workingDiv = document.createElement('div');
+    documentFragment.appendChild(workingDiv);
+    workingDiv.innerHTML = untrustedString;
+    /**
+     * Remove any elements
+     * that are blocked
+     */
+    blockedTags.forEach((blockedTag) => {
+      const getElementsToRemove = documentFragment.querySelectorAll(blockedTag);
+      for (let elementIndex = getElementsToRemove.length - 1; elementIndex >= 0; elementIndex--) {
+        const element = getElementsToRemove[elementIndex];
+        if (element.parentNode) {
+          element.parentNode.removeChild(element);
+        }
+        else {
+          documentFragment.removeChild(element);
+        }
+        /**
+         * We still need to sanitize
+         * the children of this element
+         * as they are left behind
+         */
+        const childElements = getElementChildren(element);
+        /* eslint-disable-next-line */
+        for (let childIndex = 0; childIndex < childElements.length; childIndex++) {
+          sanitizeElement(childElements[childIndex]);
+        }
+      }
+    });
+    /**
+     * Go through remaining elements and remove
+     * non-allowed attribs
+     */
+    // IE does not support .children on document fragments, only .childNodes
+    const dfChildren = getElementChildren(documentFragment);
+    /* eslint-disable-next-line */
+    for (let childIndex = 0; childIndex < dfChildren.length; childIndex++) {
+      sanitizeElement(dfChildren[childIndex]);
+    }
+    // Append document fragment to div
+    const fragmentDiv = document.createElement('div');
+    fragmentDiv.appendChild(documentFragment);
+    // First child is always the div we did our work in
+    const getInnerDiv = fragmentDiv.querySelector('div');
+    return getInnerDiv !== null ? getInnerDiv.innerHTML : fragmentDiv.innerHTML;
+  }
+  catch (err) {
+    console.error(err);
+    return '';
+  }
+};
+/**
+ * Clean up current element based on allowed attributes
+ * and then recursively dig down into any child elements to
+ * clean those up as well
+ */
+const sanitizeElement = (element) => {
+  // IE uses childNodes, so ignore nodes that are not elements
+  if (element.nodeType && element.nodeType !== 1) {
+    return;
+  }
+  for (let i = element.attributes.length - 1; i >= 0; i--) {
+    const attribute = element.attributes.item(i);
+    const attributeName = attribute.name;
+    // remove non-allowed attribs
+    if (!allowedAttributes.includes(attributeName.toLowerCase())) {
+      element.removeAttribute(attributeName);
+      continue;
+    }
+    // clean up any allowed attribs
+    // that attempt to do any JS funny-business
+    const attributeValue = attribute.value;
+    /* eslint-disable-next-line */
+    if (attributeValue != null && attributeValue.toLowerCase().includes('javascript:')) {
+      element.removeAttribute(attributeName);
+    }
+  }
+  /**
+   * Sanitize any nested children
+   */
+  const childElements = getElementChildren(element);
+  /* eslint-disable-next-line */
+  for (let i = 0; i < childElements.length; i++) {
+    sanitizeElement(childElements[i]);
+  }
+};
+/**
+ * IE doesn't always support .children
+ * so we revert to .childNodes instead
+ */
+const getElementChildren = (el) => {
+  return el.children != null ? el.children : el.childNodes;
+};
+const isSanitizerEnabled = () => {
+  var _a;
+  const win = window;
+  const config = (_a = win === null || win === void 0 ? void 0 : win.Ionic) === null || _a === void 0 ? void 0 : _a.config;
+  if (config) {
+    if (config.get) {
+      return config.get('sanitizerEnabled', true);
+    }
+    else {
+      return config.sanitizerEnabled === true || config.sanitizerEnabled === undefined;
+    }
+  }
+  return true;
+};
+const allowedAttributes = ['class', 'id', 'href', 'src', 'name', 'slot'];
+const blockedTags = ['script', 'style', 'iframe', 'meta', 'link', 'object', 'embed'];
+class IonicSafeString {
+  constructor(value) {
+    this.value = value;
+  }
+}
+
+exports.sanitizeDOMString = sanitizeDOMString;

package/dist/cjs/index-e56e09b8.js

@@ -0,0 +1,38 @@
+'use strict';
+
+/*!
+ * (C) Ionic http://ionicframework.com - MIT License
+ */
+/**
+ * Logs a warning to the console with an Ionic prefix
+ * to indicate the library that is warning the developer.
+ *
+ * @param message - The string message to be logged to the console.
+ */
+const printIonWarning = (message, ...params) => {
+  return console.warn(`[Ionic Warning]: ${message}`, ...params);
+};
+/*
+ * Logs an error to the console with an Ionic prefix
+ * to indicate the library that is warning the developer.
+ *
+ * @param message - The string message to be logged to the console.
+ * @param params - Additional arguments to supply to the console.error.
+ */
+const printIonError = (message, ...params) => {
+  return console.error(`[Ionic Error]: ${message}`, ...params);
+};
+/**
+ * Prints an error informing developers that an implementation requires an element to be used
+ * within a specific selector.
+ *
+ * @param el The web component element this is requiring the element.
+ * @param targetSelectors The selector or selectors that were not found.
+ */
+const printRequiredElementError = (el, ...targetSelectors) => {
+  return console.error(`<${el.tagName.toLowerCase()}> must be used inside ${targetSelectors.join(' or ')}.`);
+};
+
+exports.printIonError = printIonError;
+exports.printIonWarning = printIonWarning;
+exports.printRequiredElementError = printRequiredElementError;

package/dist/cjs/index.cjs.js

@@ -0,0 +1,26 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const PrivateRoute = require('./PrivateRoute-f97245ce.js');
+const environmentConfig_service = require('./environment-config.service-c8ff1f3d.js');
+const assets_service = require('./assets.service-bfa75092.js');
+const auth_store = require('./auth.store-1e630a7d.js');
+require('./index-51e8292e.js');
+require('./localstorage.service-6346a41d.js');
+require('./httpService-d2e7bf8f.js');
+require('./overlays-32df265a.js');
+require('./ionic-global-2cde9d3a.js');
+require('./hardware-back-button-92d97ff8.js');
+require('./helpers-c2496722.js');
+require('./token.service-7a41953d.js');
+
+
+
+exports.AuthService = PrivateRoute.AuthService;
+exports.PrivateRoute = PrivateRoute.PrivateRoute;
+exports.initSetupEnvironmentConfig = PrivateRoute.initSetupConfig;
+exports.setupEnvironmentConfig = PrivateRoute.setupConfig;
+exports.EnvironmentConfigService = environmentConfig_service.EnvironmentConfigService;
+exports.AssetsService = assets_service.AssetsService;
+exports.AuthStore = auth_store.AuthStore;