@sparkle-learning/core 0.0.31 → 0.0.34

package/dist/cjs/match-path-84c9f7ca.js

@@ -0,0 +1,511 @@
+'use strict';
+
+/**
+ * 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);
+};
+
+exports.addLeadingSlash = addLeadingSlash;
+exports.createKey = createKey;
+exports.createLocation = createLocation;
+exports.createPath = createPath;
+exports.hasBasename = hasBasename;
+exports.locationsAreEqual = locationsAreEqual;
+exports.matchPath = matchPath;
+exports.matchesAreEqual = matchesAreEqual;
+exports.stripBasename = stripBasename;
+exports.stripLeadingSlash = stripLeadingSlash;
+exports.stripTrailingSlash = stripTrailingSlash;

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

@@ -0,0 +1,91 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const index = require('./index-bae2a754.js');
+const icons = require('./icons-80d477f6.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) {
+    index.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 : (index.h("header", { class: "Card-header" }, this.header, " ", isOutbound ? index.h(icons.Outbound, null) : null));
+    const hoverIcon = this.hoverIcon || this.icon;
+    const content = [
+      this.img && index.h("img", { src: this.img, class: "Card-image" }),
+      index.h("div", { class: "Card-container" }, this.icon && index.h("img", { src: this.icon, class: "Card-icon Card-icon-default" }), hoverIcon && index.h("img", { src: hoverIcon, class: "Card-icon Card-icon-hover" }), this.ionicon && index.h("ion-icon", { name: this.ionicon, class: "Card-ionicon" }), this.iconset && index.h("div", { class: "Card-iconset__container" }, this.iconset.split(',').map((icon, index$1) => index.h("img", { src: icon, class: `Card-icon ${index$1 === this.activeIndex ? 'Card-icon--active' : ''}`, "data-index": index$1 }))), header, index.h("div", { class: "Card-content" }, index.h("slot", null)))
+    ];
+    if (isStatic) {
+      return (index.h("div", { class: "Card" }, content));
+    }
+    if (isOutbound) {
+      return (index.h("a", { class: "Card", href: this.href }, content));
+    }
+    return (index.h("stencil-route-link", { url: this.href, anchorClass: "Card" }, content));
+  }
+  render() { return index.h(index.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) {
+    index.registerInstance(this, hostRef);
+  }
+  render() {
+    return index.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) {
+    index.registerInstance(this, hostRef);
+  }
+  render() {
+    return (index.h(index.Host, null, index.h("sparkle-card", { header: this.goal.Name, icon: this.goal.CategoryIcon }, index.h("div", { class: "goal-header" }, index.h("ion-button", { size: "small", color: "primary", onClick: () => this.onEditGoal() }, "Edit")), index.h("p", null, this.goal.Description), index.h("sparkle-goal-progress", { percentage: this.goal.Percentage.toString() }))));
+  }
+};
+SparkleGoalItem.style = sparkleGoalItemCss;
+
+exports.sparkle_card = SparkleCard;
+exports.sparkle_cards = SparkleCards;
+exports.sparkle_goal_item = SparkleGoalItem;

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

@@ -3,7 +3,7 @@
 Object.defineProperty(exports, '__esModule', { value: true });
 
 const index = require('./index-bae2a754.js');
-const icons = require('./icons-b8a2231a.js');
+const icons = require('./icons-80d477f6.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)}";