@sparkle-learning/core 0.0.36 → 0.0.39

package/dist/esm/match-path-36fdf5c7.js

@@ -0,0 +1,499 @@
+/**
+ * TS adaption of https://github.com/pillarjs/path-to-regexp/blob/master/index.js
+ */
+/**
+ * Default configs.
+ */
+const DEFAULT_DELIMITER = '/';
+const DEFAULT_DELIMITERS = './';
+/**
+ * The main path matching regexp utility.
+ */
+const PATH_REGEXP = new RegExp([
+    // Match escaped characters that would otherwise appear in future matches.
+    // This allows the user to escape special characters that won't transform.
+    '(\\\\.)',
+    // Match Express-style parameters and un-named parameters with a prefix
+    // and optional suffixes. Matches appear as:
+    //
+    // "/:test(\\d+)?" => ["/", "test", "\d+", undefined, "?"]
+    // "/route(\\d+)"  => [undefined, undefined, undefined, "\d+", undefined]
+    '(?:\\:(\\w+)(?:\\(((?:\\\\.|[^\\\\()])+)\\))?|\\(((?:\\\\.|[^\\\\()])+)\\))([+*?])?'
+].join('|'), 'g');
+/**
+ * Parse a string for the raw tokens.
+ */
+const parse = (str, options) => {
+    var tokens = [];
+    var key = 0;
+    var index = 0;
+    var path = '';
+    var defaultDelimiter = (options && options.delimiter) || DEFAULT_DELIMITER;
+    var delimiters = (options && options.delimiters) || DEFAULT_DELIMITERS;
+    var pathEscaped = false;
+    var res;
+    while ((res = PATH_REGEXP.exec(str)) !== null) {
+        var m = res[0];
+        var escaped = res[1];
+        var offset = res.index;
+        path += str.slice(index, offset);
+        index = offset + m.length;
+        // Ignore already escaped sequences.
+        if (escaped) {
+            path += escaped[1];
+            pathEscaped = true;
+            continue;
+        }
+        var prev = '';
+        var next = str[index];
+        var name = res[2];
+        var capture = res[3];
+        var group = res[4];
+        var modifier = res[5];
+        if (!pathEscaped && path.length) {
+            var k = path.length - 1;
+            if (delimiters.indexOf(path[k]) > -1) {
+                prev = path[k];
+                path = path.slice(0, k);
+            }
+        }
+        // Push the current path onto the tokens.
+        if (path) {
+            tokens.push(path);
+            path = '';
+            pathEscaped = false;
+        }
+        var partial = prev !== '' && next !== undefined && next !== prev;
+        var repeat = modifier === '+' || modifier === '*';
+        var optional = modifier === '?' || modifier === '*';
+        var delimiter = prev || defaultDelimiter;
+        var pattern = capture || group;
+        tokens.push({
+            name: name || key++,
+            prefix: prev,
+            delimiter: delimiter,
+            optional: optional,
+            repeat: repeat,
+            partial: partial,
+            pattern: pattern ? escapeGroup(pattern) : '[^' + escapeString(delimiter) + ']+?'
+        });
+    }
+    // Push any remaining characters.
+    if (path || index < str.length) {
+        tokens.push(path + str.substr(index));
+    }
+    return tokens;
+};
+/**
+ * Escape a regular expression string.
+ */
+const escapeString = (str) => {
+    return str.replace(/([.+*?=^!:${}()[\]|/\\])/g, '\\$1');
+};
+/**
+ * Escape the capturing group by escaping special characters and meaning.
+ */
+const escapeGroup = (group) => {
+    return group.replace(/([=!:$/()])/g, '\\$1');
+};
+/**
+ * Get the flags for a regexp from the options.
+ */
+const flags = (options) => {
+    return options && options.sensitive ? '' : 'i';
+};
+/**
+ * Pull out keys from a regexp.
+ */
+const regexpToRegexp = (path, keys) => {
+    if (!keys)
+        return path;
+    // Use a negative lookahead to match only capturing groups.
+    var groups = path.source.match(/\((?!\?)/g);
+    if (groups) {
+        for (var i = 0; i < groups.length; i++) {
+            keys.push({
+                name: i,
+                prefix: null,
+                delimiter: null,
+                optional: false,
+                repeat: false,
+                partial: false,
+                pattern: null
+            });
+        }
+    }
+    return path;
+};
+/**
+ * Transform an array into a regexp.
+ */
+const arrayToRegexp = (path, keys, options) => {
+    var parts = [];
+    for (var i = 0; i < path.length; i++) {
+        parts.push(pathToRegexp(path[i], keys, options).source);
+    }
+    return new RegExp('(?:' + parts.join('|') + ')', flags(options));
+};
+/**
+ * Create a path regexp from string input.
+ */
+const stringToRegexp = (path, keys, options) => {
+    return tokensToRegExp(parse(path, options), keys, options);
+};
+/**
+ * Expose a function for taking tokens and returning a RegExp.
+ */
+const tokensToRegExp = (tokens, keys, options) => {
+    options = options || {};
+    var strict = options.strict;
+    var end = options.end !== false;
+    var delimiter = escapeString(options.delimiter || DEFAULT_DELIMITER);
+    var delimiters = options.delimiters || DEFAULT_DELIMITERS;
+    var endsWith = [].concat(options.endsWith || []).map(escapeString).concat('$').join('|');
+    var route = '';
+    var isEndDelimited = false;
+    // Iterate over the tokens and create our regexp string.
+    for (var i = 0; i < tokens.length; i++) {
+        var token = tokens[i];
+        if (typeof token === 'string') {
+            route += escapeString(token);
+            isEndDelimited = i === tokens.length - 1 && delimiters.indexOf(token[token.length - 1]) > -1;
+        }
+        else {
+            var prefix = escapeString(token.prefix || '');
+            var capture = token.repeat
+                ? '(?:' + token.pattern + ')(?:' + prefix + '(?:' + token.pattern + '))*'
+                : token.pattern;
+            if (keys)
+                keys.push(token);
+            if (token.optional) {
+                if (token.partial) {
+                    route += prefix + '(' + capture + ')?';
+                }
+                else {
+                    route += '(?:' + prefix + '(' + capture + '))?';
+                }
+            }
+            else {
+                route += prefix + '(' + capture + ')';
+            }
+        }
+    }
+    if (end) {
+        if (!strict)
+            route += '(?:' + delimiter + ')?';
+        route += endsWith === '$' ? '$' : '(?=' + endsWith + ')';
+    }
+    else {
+        if (!strict)
+            route += '(?:' + delimiter + '(?=' + endsWith + '))?';
+        if (!isEndDelimited)
+            route += '(?=' + delimiter + '|' + endsWith + ')';
+    }
+    return new RegExp('^' + route, flags(options));
+};
+/**
+ * Normalize the given path string, returning a regular expression.
+ *
+ * An empty array can be passed in for the keys, which will hold the
+ * placeholder key descriptions. For example, using `/user/:id`, `keys` will
+ * contain `[{ name: 'id', delimiter: '/', optional: false, repeat: false }]`.
+ */
+const pathToRegexp = (path, keys, options) => {
+    if (path instanceof RegExp) {
+        return regexpToRegexp(path, keys);
+    }
+    if (Array.isArray(path)) {
+        return arrayToRegexp(path, keys, options);
+    }
+    return stringToRegexp(path, keys, options);
+};
+
+const hasBasename = (path, prefix) => {
+    return (new RegExp('^' + prefix + '(\\/|\\?|#|$)', 'i')).test(path);
+};
+const stripBasename = (path, prefix) => {
+    return hasBasename(path, prefix) ? path.substr(prefix.length) : path;
+};
+const stripTrailingSlash = (path) => {
+    return path.charAt(path.length - 1) === '/' ? path.slice(0, -1) : path;
+};
+const addLeadingSlash = (path) => {
+    return path.charAt(0) === '/' ? path : '/' + path;
+};
+const stripLeadingSlash = (path) => {
+    return path.charAt(0) === '/' ? path.substr(1) : path;
+};
+const parsePath = (path) => {
+    let pathname = path || '/';
+    let search = '';
+    let hash = '';
+    const hashIndex = pathname.indexOf('#');
+    if (hashIndex !== -1) {
+        hash = pathname.substr(hashIndex);
+        pathname = pathname.substr(0, hashIndex);
+    }
+    const searchIndex = pathname.indexOf('?');
+    if (searchIndex !== -1) {
+        search = pathname.substr(searchIndex);
+        pathname = pathname.substr(0, searchIndex);
+    }
+    return {
+        pathname,
+        search: search === '?' ? '' : search,
+        hash: hash === '#' ? '' : hash,
+        query: {},
+        key: ''
+    };
+};
+const createPath = (location) => {
+    const { pathname, search, hash } = location;
+    let path = pathname || '/';
+    if (search && search !== '?') {
+        path += (search.charAt(0) === '?' ? search : `?${search}`);
+    }
+    if (hash && hash !== '#') {
+        path += (hash.charAt(0) === '#' ? hash : `#${hash}`);
+    }
+    return path;
+};
+const parseQueryString = (query) => {
+    if (!query) {
+        return {};
+    }
+    return (/^[?#]/.test(query) ? query.slice(1) : query)
+        .split('&')
+        .reduce((params, param) => {
+        let [key, value] = param.split('=');
+        params[key] = value ? decodeURIComponent(value.replace(/\+/g, ' ')) : '';
+        return params;
+    }, {});
+};
+
+const isAbsolute = (pathname) => {
+    return pathname.charAt(0) === '/';
+};
+const createKey = (keyLength) => {
+    return Math.random().toString(36).substr(2, keyLength);
+};
+// About 1.5x faster than the two-arg version of Array#splice()
+const spliceOne = (list, index) => {
+    for (let i = index, k = i + 1, n = list.length; k < n; i += 1, k += 1) {
+        list[i] = list[k];
+    }
+    list.pop();
+};
+// This implementation is based heavily on node's url.parse
+const resolvePathname = (to, from = '') => {
+    let fromParts = from && from.split('/') || [];
+    let hasTrailingSlash;
+    let up = 0;
+    const toParts = to && to.split('/') || [];
+    const isToAbs = to && isAbsolute(to);
+    const isFromAbs = from && isAbsolute(from);
+    const mustEndAbs = isToAbs || isFromAbs;
+    if (to && isAbsolute(to)) {
+        // to is absolute
+        fromParts = toParts;
+    }
+    else if (toParts.length) {
+        // to is relative, drop the filename
+        fromParts.pop();
+        fromParts = fromParts.concat(toParts);
+    }
+    if (!fromParts.length) {
+        return '/';
+    }
+    if (fromParts.length) {
+        const last = fromParts[fromParts.length - 1];
+        hasTrailingSlash = (last === '.' || last === '..' || last === '');
+    }
+    else {
+        hasTrailingSlash = false;
+    }
+    for (let i = fromParts.length; i >= 0; i--) {
+        const part = fromParts[i];
+        if (part === '.') {
+            spliceOne(fromParts, i);
+        }
+        else if (part === '..') {
+            spliceOne(fromParts, i);
+            up++;
+        }
+        else if (up) {
+            spliceOne(fromParts, i);
+            up--;
+        }
+    }
+    if (!mustEndAbs) {
+        for (; up--; up) {
+            fromParts.unshift('..');
+        }
+    }
+    if (mustEndAbs && fromParts[0] !== '' && (!fromParts[0] || !isAbsolute(fromParts[0]))) {
+        fromParts.unshift('');
+    }
+    let result = fromParts.join('/');
+    if (hasTrailingSlash && result.substr(-1) !== '/') {
+        result += '/';
+    }
+    return result;
+};
+const valueEqual = (a, b) => {
+    if (a === b) {
+        return true;
+    }
+    if (a == null || b == null) {
+        return false;
+    }
+    if (Array.isArray(a)) {
+        return Array.isArray(b) && a.length === b.length && a.every((item, index) => {
+            return valueEqual(item, b[index]);
+        });
+    }
+    const aType = typeof a;
+    const bType = typeof b;
+    if (aType !== bType) {
+        return false;
+    }
+    if (aType === 'object') {
+        const aValue = a.valueOf();
+        const bValue = b.valueOf();
+        if (aValue !== a || bValue !== b) {
+            return valueEqual(aValue, bValue);
+        }
+        const aKeys = Object.keys(a);
+        const bKeys = Object.keys(b);
+        if (aKeys.length !== bKeys.length) {
+            return false;
+        }
+        return aKeys.every((key) => {
+            return valueEqual(a[key], b[key]);
+        });
+    }
+    return false;
+};
+const locationsAreEqual = (a, b) => {
+    return a.pathname === b.pathname &&
+        a.search === b.search &&
+        a.hash === b.hash &&
+        a.key === b.key &&
+        valueEqual(a.state, b.state);
+};
+const createLocation = (path, state, key, currentLocation) => {
+    let location;
+    if (typeof path === 'string') {
+        // Two-arg form: push(path, state)
+        location = parsePath(path);
+        if (state !== undefined) {
+            location.state = state;
+        }
+    }
+    else {
+        // One-arg form: push(location)
+        location = Object.assign({ pathname: '' }, path);
+        if (location.search && location.search.charAt(0) !== '?') {
+            location.search = '?' + location.search;
+        }
+        if (location.hash && location.hash.charAt(0) !== '#') {
+            location.hash = '#' + location.hash;
+        }
+        if (state !== undefined && location.state === undefined) {
+            location.state = state;
+        }
+    }
+    try {
+        location.pathname = decodeURI(location.pathname);
+    }
+    catch (e) {
+        if (e instanceof URIError) {
+            throw new URIError('Pathname "' + location.pathname + '" could not be decoded. ' +
+                'This is likely caused by an invalid percent-encoding.');
+        }
+        else {
+            throw e;
+        }
+    }
+    location.key = key;
+    if (currentLocation) {
+        // Resolve incomplete/relative pathname relative to current location.
+        if (!location.pathname) {
+            location.pathname = currentLocation.pathname;
+        }
+        else if (location.pathname.charAt(0) !== '/') {
+            location.pathname = resolvePathname(location.pathname, currentLocation.pathname);
+        }
+    }
+    else {
+        // When there is no prior location and pathname is empty, set it to /
+        if (!location.pathname) {
+            location.pathname = '/';
+        }
+    }
+    location.query = parseQueryString(location.search || '');
+    return location;
+};
+
+let cacheCount = 0;
+const patternCache = {};
+const cacheLimit = 10000;
+// Memoized function for creating the path match regex
+const compilePath = (pattern, options) => {
+    const cacheKey = `${options.end}${options.strict}`;
+    const cache = patternCache[cacheKey] || (patternCache[cacheKey] = {});
+    const cachePattern = JSON.stringify(pattern);
+    if (cache[cachePattern]) {
+        return cache[cachePattern];
+    }
+    const keys = [];
+    const re = pathToRegexp(pattern, keys, options);
+    const compiledPattern = { re, keys };
+    if (cacheCount < cacheLimit) {
+        cache[cachePattern] = compiledPattern;
+        cacheCount += 1;
+    }
+    return compiledPattern;
+};
+/**
+ * Public API for matching a URL pathname to a path pattern.
+ */
+const matchPath = (pathname, options = {}) => {
+    if (typeof options === 'string') {
+        options = { path: options };
+    }
+    const { path = '/', exact = false, strict = false } = options;
+    const { re, keys } = compilePath(path, { end: exact, strict });
+    const match = re.exec(pathname);
+    if (!match) {
+        return null;
+    }
+    const [url, ...values] = match;
+    const isExact = pathname === url;
+    if (exact && !isExact) {
+        return null;
+    }
+    return {
+        path,
+        url: path === '/' && url === '' ? '/' : url,
+        isExact,
+        params: keys.reduce((memo, key, index) => {
+            memo[key.name] = values[index];
+            return memo;
+        }, {})
+    };
+};
+const matchesAreEqual = (a, b) => {
+    if (a == null && b == null) {
+        return true;
+    }
+    if (b == null) {
+        return false;
+    }
+    return a && b &&
+        a.path === b.path &&
+        a.url === b.url &&
+        valueEqual(a.params, b.params);
+};
+
+export { matchesAreEqual as a, addLeadingSlash as b, createLocation as c, createKey as d, stripBasename as e, createPath as f, stripLeadingSlash as g, hasBasename as h, locationsAreEqual as l, matchPath as m, stripTrailingSlash as s };

package/dist/esm/{md.transition-f6126011.js → md.transition-cff16bf3.js}

@@ -1,6 +1,6 @@
-import { c as createAnimation } from './animation-12377cb3.js';
-import { g as getIonPageElement } from './index-2b84cad2.js';
-import './helpers-bf0e23d6.js';
+import { c as createAnimation } from './animation-e0716b39.js';
+import { g as getIonPageElement } from './index-b4b4e503.js';
+import './helpers-03073fe4.js';
 import './index-c04b9ed5.js';
 
 /*!

package/dist/esm/{menu-toggle-util-bace8ae6.js → menu-toggle-util-59241733.js}

@@ -1,4 +1,4 @@
-import { m as menuController } from './index-cded2d87.js';
+import { m as menuController } from './index-dedabca0.js';
 
 /*!
  * (C) Ionic http://ionicframework.com - MIT License

package/dist/esm/{overlays-3b4dca92.js → overlays-bdd9344a.js}

@@ -1,6 +1,6 @@
 import { g as getIonMode, c as config } from './ionic-global-4903e23e.js';
 import { OVERLAY_BACK_BUTTON_PRIORITY } from './hardware-back-button-fa04d6e9.js';
-import { c as componentOnReady, f as focusElement, a as addEventListener, r as removeEventListener, g as getElementRoot } from './helpers-bf0e23d6.js';
+import { c as componentOnReady, f as focusElement, a as addEventListener, r as removeEventListener, g as getElementRoot } from './helpers-03073fe4.js';
 
 /*!
  * (C) Ionic http://ionicframework.com - MIT License
@@ -488,4 +488,4 @@ const safeCall = (handler, arg) => {
 };
 const BACKDROP = 'backdrop';
 
-export { BACKDROP as B, alertController as a, present as b, activeAnimations as c, dismiss as d, eventMethod as e, popoverController as f, getOverlay as g, actionSheetController as h, isCancel as i, focusFirstDescendant as j, modalController as m, prepareOverlay as p, safeCall as s, toastController as t };
+export { BACKDROP as B, present as a, activeAnimations as b, popoverController as c, dismiss as d, eventMethod as e, actionSheetController as f, getOverlay as g, alertController as h, isCancel as i, focusFirstDescendant as j, modalController as m, prepareOverlay as p, safeCall as s, toastController as t };

package/dist/esm/{purify-85bfcc69.js → purify-7085b248.js}

@@ -1,4 +1,4 @@
-import { c as createCommonjsModule, b as commonjsGlobal } from './auth.store-dba2c2da.js';
+import { b as createCommonjsModule, d as commonjsGlobal } from './auth.store-633e8414.js';
 
 var purify = createCommonjsModule(function (module, exports) {
 /*! @license DOMPurify 2.3.6 | (c) Cure53 and other contributors | Released under the Apache license 2.0 and Mozilla Public License 2.0 | github.com/cure53/DOMPurify/blob/2.3.6/LICENSE */

package/dist/esm/sparkle-animation-player.entry.js

@@ -1,6 +1,6 @@
 import { r as registerInstance, h, c as getAssetPath, e as getElement } from './index-c04b9ed5.js';
 import { g as get } from './localstorage.service-4bf408c8.js';
-import { S as SparkleGlobal } from './util-6ef753e9.js';
+import { S as SparkleGlobal } from './util-a831d09d.js';
 
 //https://github.com/bazh/subtitles-parser/blob/master/index.js
 class CaptionParser {

package/dist/esm/sparkle-card_3.entry.js

@@ -0,0 +1,85 @@
+import { r as registerInstance, h, H as Host } from './index-c04b9ed5.js';
+import { O as Outbound } from './icons-90b957ab.js';
+
+const cardCss = "sparkle-card{display:block;font-size:12px;max-width:30em}.Card{background-color:var(--background);border-radius:4px;box-shadow:0px 0.175em 0.5em rgba(2, 8, 20, 0.1), 0px 0.085em 0.175em rgba(2, 8, 20, 0.08);color:var(--text-color--light);display:flex;flex-direction:column;font-size:inherit;font-weight:normal;height:100%;justify-content:flex-start;line-height:1.6;transition:box-shadow 150ms ease, transform 150ms ease;width:100%;overflow:hidden}.Card-with-image{grid-row:span 2}.Card-without-image{font-size:12px}.Card-container{padding:1.65em 2em 1.65em}.Card-image{width:100%;height:auto}.Card-icon,.Card-iconset__container{width:48px;height:48px;margin-bottom:1.2em;border-radius:50%;object-fit:cover;background:rgb(246, 248, 251)}.Card-icon-hover{display:none}.Card-iconset__container{position:relative}.Card-iconset__container .Card-icon{position:absolute;opacity:0;transition:0.8s opacity}.Card-iconset__container .Card-icon--active{opacity:1}.Card-ionicon{width:48px;height:48px;float:left;margin-right:1em}@media (hover: hover){.Card[href]:hover{box-shadow:0 0.35em 1.175em rgba(2, 8, 20, 0.1), 0 0.175em 0.5em rgba(2, 8, 20, 0.08);transform:translateY(-1px)}.Card[href]:hover .Card-icon-default{display:none}.Card[href]:hover .Card-icon-hover{display:block}}.Card-content>*:first-child{margin-top:0}.Card-content>*:last-child{margin-bottom:0}.Card-content>*{margin:0 0 0.65em}.Card-header{color:var(--text-color--dark);font-size:1.4em;font-weight:500;line-height:1.4;margin-bottom:0.45em}.Card-without-image .Card-header{margin-bottom:0.3em}.Card-header>svg{fill:currentColor;height:1em;margin-bottom:-0.125em;width:auto}.Card-size-lg{font-size:14px}.Card-size-lg .Card-icon,.Card-size-lg .Card-ionicon,.Card-size-lg .Card-iconset__container{width:80px;height:80px}.Card-size-lg.Card-without-image .Card-header{font-size:20px}sparkle-card.disabled,sparkle-card[disabled]{position:relative}sparkle-card.disabled::after,sparkle-card[disabled]::after{position:absolute;top:0;right:0;left:0;bottom:0;background:rgba(232, 232, 232, 0.5);pointer-events:none;content:''}aside sparkle-card{max-width:240px}aside .Card-container{display:grid;grid-template-columns:minmax(0, max-content) 1fr;grid-template-rows:minmax(0, min-content);grid-template-areas:'icon title'\r\n    'icon body'}aside .Card-icon{width:32px;height:32px;margin-right:16px;margin-bottom:0;grid-area:icon}aside .Card-header{grid-area:title}aside .Card-header::after{background-image:url('/docs/assets/img/new-tab.svg');display:inline-block;height:13px;width:13px;background-size:13px 13px;margin-left:4px;content:''}aside .Card-content{grid-area:body;max-height:42px;overflow:hidden;text-overflow:ellipsis;display:-webkit-box;-webkit-line-clamp:2;-webkit-box-orient:vertical}aside .Card-icon+.Card-content{margin-top:-6px}.markdown-content p sparkle-card{margin-top:1em}";
+
+const SparkleCard = class {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+    this.activeIndex = 0;
+    this.rotationTime = 6000; // 4 seconds
+  }
+  hostData() {
+    return {
+      class: {
+        'Card-with-image': typeof this.img !== 'undefined',
+        'Card-without-image': typeof this.img === 'undefined',
+        'Card-size-lg': this.size === 'lg',
+      }
+    };
+  }
+  componentWillLoad() {
+    if (typeof this.iconset !== 'undefined') {
+      return;
+    }
+    this.activeIndex = 0;
+    this.rotationTime = 4000 + (Math.random() * 2000); // 4 - 6 seconds - randomize it a bit
+    // make the first transiton happen a bit faster
+    setInterval(this.tic.bind(this), this.rotationTime);
+    setTimeout(this.tic.bind(this), this.rotationTime / 3);
+  }
+  componentWillUnload() {
+    clearInterval(this.interval);
+  }
+  tic() {
+    if (typeof this.iconset !== 'undefined' && this.activeIndex >= this.iconset.split(',').length - 1) {
+      return this.activeIndex = 0;
+    }
+    this.activeIndex++;
+  }
+  __stencil_render() {
+    const isStatic = typeof this.href === 'undefined';
+    const isOutbound = typeof this.href !== 'undefined' ? /^http/.test(this.href) : false;
+    const header = this.header === 'undefined' ? null : (h("header", { class: "Card-header" }, this.header, " ", isOutbound ? h(Outbound, null) : null));
+    const hoverIcon = this.hoverIcon || this.icon;
+    const content = [
+      this.img && h("img", { src: this.img, class: "Card-image" }),
+      h("div", { class: "Card-container" }, this.icon && h("img", { src: this.icon, class: "Card-icon Card-icon-default" }), hoverIcon && h("img", { src: hoverIcon, class: "Card-icon Card-icon-hover" }), this.ionicon && h("ion-icon", { name: this.ionicon, class: "Card-ionicon" }), this.iconset && h("div", { class: "Card-iconset__container" }, this.iconset.split(',').map((icon, index) => h("img", { src: icon, class: `Card-icon ${index === this.activeIndex ? 'Card-icon--active' : ''}`, "data-index": index }))), header, h("div", { class: "Card-content" }, h("slot", null)))
+    ];
+    if (isStatic) {
+      return (h("div", { class: "Card" }, content));
+    }
+    if (isOutbound) {
+      return (h("a", { class: "Card", href: this.href }, content));
+    }
+    return (h("stencil-route-link", { url: this.href, anchorClass: "Card" }, content));
+  }
+  render() { return h(Host, this.hostData(), this.__stencil_render()); }
+};
+SparkleCard.style = cardCss;
+
+const cardsCss = "sparkle-cards{display:grid;font-size:12px;grid-template-columns:repeat(auto-fit, minmax(240px, 1fr));grid-gap:1.35rem}sparkle-cards>sparkle-card{font-size:inherit;max-width:none}sparkle-cards>sparkle-card.tall{grid-row:span 2}sparkle-cards>sparkle-card.wide{grid-column:span 2}sparkle-cards.prioritized>sparkle-card:nth-child(-n+5){font-size:1.25em}sparkle-cards.prioritized>sparkle-card:first-child{grid-row:span 2}sparkle-cards.max-measure>sparkle-card{max-width:50%}";
+
+const SparkleCards = class {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+  }
+  render() {
+    return h("slot", null);
+  }
+};
+SparkleCards.style = cardsCss;
+
+const sparkleGoalItemCss = ":host{display:block}.Card-content{padding-top:8px}.goal-header{display:flex;justify-content:flex-end;margin-top:-40px !important}";
+
+const SparkleGoalItem = class {
+  constructor(hostRef) {
+    registerInstance(this, hostRef);
+  }
+  render() {
+    return (h(Host, null, h("sparkle-card", { header: this.goal.Name, icon: this.goal.CategoryIcon }, h("div", { class: "goal-header" }, h("ion-button", { size: "small", color: "primary", onClick: () => this.onEditGoal() }, "Edit")), h("p", null, this.goal.Description), h("sparkle-goal-progress", { percentage: this.goal.Percentage.toString() }))));
+  }
+};
+SparkleGoalItem.style = sparkleGoalItemCss;
+
+export { SparkleCard as sparkle_card, SparkleCards as sparkle_cards, SparkleGoalItem as sparkle_goal_item };

package/dist/esm/sparkle-code.entry.js

@@ -1,5 +1,5 @@
 import { r as registerInstance, h, H as Host, e as getElement } from './index-c04b9ed5.js';
-import { C as CheckmarkSoft } from './icons-9b62a1ec.js';
+import { C as CheckmarkSoft } from './icons-90b957ab.js';
 
 const codeCss = "code[class*=\"language-\"],pre[class*=\"language-\"]{color:#4d4d4c;background:none;white-space:pre;word-spacing:normal;word-break:normal;word-wrap:normal;line-height:1.5;-moz-tab-size:4;-o-tab-size:4;tab-size:4;-webkit-hyphens:none;-moz-hyphens:none;-ms-hyphens:none;hyphens:none}pre[class*=\"language-\"],:not(pre)>code[class*=\"language-\"]{background:hsl(30, 20%, 25%)}pre[class*=\"language-\"]{padding:1em;margin:.5em 0;overflow:auto;border:.3em solid hsl(30, 20%, 40%);border-radius:.5em;box-shadow:1px 1px .5em black inset}:not(pre)>code[class*=\"language-\"]{padding:.15em .2em .05em;border-radius:.3em;border:.13em solid hsl(30, 20%, 40%);box-shadow:1px 1px .3em -.1em black inset;white-space:normal}.token.comment,.token.prolog,.token.doctype,.token.cdata{color:#8c9296}.token.punctuation{opacity:.7}.namespace{opacity:.7}.token.tag{color:#91c5ff}.token.tag .token.tag{color:#2b90ff}.token.property,.token.attr-name,.token.boolean,.token.number,.token.constant,.token.symbol{color:#8454ff}.token.selector,.token.char,.token.function,.token.builtin,.token.inserted{color:#ff6810}.token.operator,.token.string,.token.entity,.token.url,.token.attr-value,.language-css .token.string,.style .token.string,.token.variable{color:#42b983}.token.atrule{color:#ffbb01}.token.regex,.token.keyword,.token.important{color:#f55073}.token.important,.token.bold{font-weight:bold}.token.italic{font-style:italic}.token.entity{cursor:help}.token.deleted{color:red}sparkle-code[language=\"shell\"]>pre{background-color:var(--text-color--dark);border-radius:7px}sparkle-code[language=\"shell\"]:before{display:none}sparkle-code[language=\"shell\"] code{color:rgba(255, 255, 255, 0.7);font-size:13px}sparkle-code[language=\"shell\"] .token{color:inherit}sparkle-code[language=\"shell\"] .token.prompt{color:#fb96f9;user-select:none}sparkle-code[language=\"shell\"] .token.comment{color:rgba(255, 255, 255, 0.45)}sparkle-code{display:block;position:relative}sparkle-code:before{color:#bdc5d1;content:attr(language);font-family:var(--code-font-family);font-size:10px;letter-spacing:0.05em;line-height:1;padding:0.75em;position:absolute;right:0;text-transform:uppercase;top:0}sparkle-code[language=\"shell\"] pre{white-space:pre-wrap}.code-text__copy{position:absolute;right:0;top:-1.6rem;height:20px}.code-text__copy-link,.code-text__copy-confirmation{padding:4px 5px;font-size:12px;line-height:12px;font-weight:600;position:absolute;right:0;top:0}.code-text__copy-link{transition:0.2s transform ,\r\n    0.2s opacity,\r\n    0.2s color;color:#70A4FF;background-color:#E0EEFF;border-radius:4px;display:inline-block;cursor:pointer;opacity:1;transform:translate3d(0,0,0);z-index:5}.code-text__copy-link:hover{color:var(--blue)}.code-text__copy-confirmation{transition:0.2s transform ,\r\n    0.2s opacity;color:#0ec254;opacity:0;transform:translate3d(0,5px,0);z-index:1;display:flex;align-items:center;height:20px;padding:0}.code-text__copy-confirmation svg{fill:#0ec254;margin-right:-4px}.show-confirmation .code-text__copy-link{opacity:0;transform:translate3d(0,-5px,0);pointer-events:none}.show-confirmation .code-text__copy-confirmation{opacity:1;transform:translate3d(0,0,0)}";