erudit 3.0.0-dev.9 → 4.0.0-dev.2

package/shared/types/mainContent.ts

@@ -0,0 +1,69 @@
+import type { FinalizedProse } from '@jsprose/core';
+import type { ContentType } from '@erudit-js/core/content/type';
+import type { TopicPart } from '@erudit-js/core/content/topic';
+import type { ContentFlags } from '@erudit-js/core/content/flags';
+import type { ContentContribution } from '@erudit-js/core/content/contributions';
+import type { ResolvedTocItem } from '@erudit-js/prose';
+import type { ContentSeo } from '@erudit-js/core/content/seo';
+
+export interface MainContentBase {
+    type: ContentType;
+    breadcrumbs: Breadcrumbs;
+    fullId: string;
+    shortId: string;
+    contentRelativePath: string;
+    title: string;
+    bookTitle?: string;
+    description?: string;
+    decoration?: string;
+    flags?: ContentFlags;
+    stats?: ContentStats;
+    connections?: ContentConnections;
+    contributions?: ContentContribution[];
+    seo?: ContentSeo;
+}
+
+export interface MainContentChildrenItem {
+    type: ContentType;
+    link: string;
+    title: string;
+    description?: string;
+    quickLinks?: ElementSnippet[];
+    stats?: ContentStats;
+}
+
+//
+//
+//
+
+export type MainContentTopicPart = MainContentBase &
+    FinalizedProse & {
+        type: 'topic';
+        part: TopicPart;
+        parts: TopicPart[];
+        snippets?: ElementSnippet[];
+        toc?: ResolvedTocItem[];
+    };
+
+export type MainContentPage = MainContentBase &
+    FinalizedProse & {
+        type: 'page';
+        snippets?: ElementSnippet[];
+        toc?: ResolvedTocItem[];
+    };
+
+export type MainContentGroup = MainContentBase & {
+    type: 'group';
+    children: MainContentChildrenItem[];
+};
+
+export type MainContentBook = MainContentBase & {
+    type: 'book';
+    children: MainContentChildrenItem[];
+};
+
+export type MainContent =
+    | MainContentTopicPart
+    | MainContentPage
+    | MainContentGroup
+    | MainContentBook;

package/shared/types/news.ts

@@ -0,0 +1,13 @@
+import type { FinalizedProse } from '@jsprose/core';
+
+export interface NewsBatch {
+    items: NewsItem[];
+    nextIndex?: number;
+    /** Only present in the first batch with index 0! */
+    total?: number;
+}
+
+export interface NewsItem {
+    date: string;
+    content: FinalizedProse;
+}

package/shared/types/preview.ts

@@ -0,0 +1,28 @@
+import type { FinalizedProse } from '@jsprose/core';
+import type { PreviewRequest } from '@erudit-js/core/preview/request';
+import type { ContentType } from '@erudit-js/core/content/type';
+
+export type PreviewState = {
+    opened: boolean;
+    request: PreviewRequest | undefined;
+    history: PreviewRequest[];
+    blink: number;
+};
+
+export type PreviewContentPage = {
+    content:
+        | { type: 'topic'; topicPart: string }
+        | { type: Exclude<ContentType, 'topic'> };
+    title: string;
+    description?: string;
+    bookTitle?: string;
+    link: string;
+};
+
+export type PreviewContentUnique = {
+    link: string;
+    contentTitle: string;
+    elementTitle?: string;
+    schemaName: string;
+    fadeOverlay?: boolean;
+} & FinalizedProse;

package/shared/types/runtimeConfig.ts

@@ -0,0 +1,64 @@
+import type { EruditMode } from '@erudit-js/core/mode';
+import type { EruditAdsBanners } from '@erudit-js/core/eruditConfig/ads';
+import type { EruditLanguage } from '@erudit-js/core/eruditConfig/language';
+import type { EruditCustomLinks } from '@erudit-js/core/eruditConfig/links';
+import type { EruditRepository } from '@erudit-js/core/eruditConfig/repository';
+import type { EruditSponsors } from '@erudit-js/core/sponsor';
+import type { EruditContributors } from '@erudit-js/core/contributor';
+import type { EruditIndexPage } from '@erudit-js/core/eruditConfig/indexPage';
+import type { EruditSiteFaviconResolved } from '@erudit-js/core/eruditConfig/site';
+import type { EruditSeo } from '@erudit-js/core/eruditConfig/seo';
+import type { EruditAnalytics } from '@erudit-js/core/eruditConfig/analytics';
+
+export interface EruditRuntimeConfigPaths {
+    package: string;
+    module: string;
+    app: string;
+    server: string;
+    project: string;
+    build: string;
+}
+
+export interface EruditRuntimeConfig {
+    paths: EruditRuntimeConfigPaths;
+    project: {
+        elements: string[];
+        countElements: (string | string[])[];
+        indexPage?: EruditIndexPage;
+    };
+}
+
+export interface EruditPublicRuntimeConfig {
+    mode: EruditMode;
+    version: string;
+    project: {
+        language: EruditLanguage;
+        originUrl: string;
+        baseUrl: string;
+        siteInfo: {
+            title?: string;
+            short?: string | false;
+            logotype?: string | false;
+            favicon?: EruditSiteFaviconResolved;
+        };
+        seo?: EruditSeo;
+        debug: {
+            log: boolean;
+            slowTransition: boolean;
+            ads: boolean;
+            fakeApi: {
+                repository: boolean;
+            };
+            analytics?: boolean;
+        };
+        repository?: EruditRepository & { _link: string };
+        style?: {
+            brandColor?: string;
+        };
+        customLinks?: EruditCustomLinks;
+        contributors?: EruditContributors;
+        sponsors?: EruditSponsors;
+        ads?: EruditAdsBanners;
+        analytics?: EruditAnalytics;
+    };
+}

package/shared/types/search.ts

@@ -0,0 +1,79 @@
+//
+// Commands
+//
+
+import type { MaybeMyIconName } from '#my-icons';
+
+export interface SearchCommandInit {
+    type: 'init';
+    baseUrl: string;
+    cacheId: string;
+    language: LanguageCode;
+}
+
+export interface SearchCommandSearch {
+    type: 'search';
+    id: number;
+    query: string;
+}
+
+export interface SearchCommandMore {
+    type: 'more';
+    id: number; // added: identify which search to paginate
+}
+
+export type SearchCommand =
+    | SearchCommandInit
+    | SearchCommandSearch
+    | SearchCommandMore;
+
+//
+// Responses
+//
+
+export interface SearchResponseError {
+    type: 'error';
+    message: string;
+}
+
+export interface SearchResponseResults {
+    type: 'results';
+    entries: SearchEntry[];
+    hasMore: boolean;
+}
+
+export type SearchResponse = SearchResponseError | SearchResponseResults;
+
+//
+//
+//
+
+export interface SearchStatusVariant {
+    id: string;
+    icon?: MaybeMyIconName;
+    message?: string;
+}
+
+export interface SearchEntry {
+    category: string;
+    title: string;
+    link: string;
+    description?: string;
+    synonyms?: string[];
+    location?: string;
+}
+
+export type ResolvedSearchEntry = SearchEntry & {
+    id: number;
+    categoryPriority: number;
+};
+
+export interface SearchEntryCategory {
+    id: string;
+    priority: number;
+}
+
+export interface SearchEntriesList {
+    category: SearchEntryCategory;
+    entries: SearchEntry[];
+}

package/shared/utils/contentTypePath.ts

@@ -0,0 +1,63 @@
+import { type TopicPart, isTopicPart } from '@erudit-js/core/content/topic';
+import { type ContentType, isContentType } from '@erudit-js/core/content/type';
+
+interface OtherContentTypePath {
+    type: 'book' | 'group' | 'page';
+    contentId: string;
+}
+
+interface TopicContentTypePath {
+    type: 'topic';
+    topicPart: TopicPart;
+    contentId: string;
+}
+
+export type ContentTypePath = OtherContentTypePath | TopicContentTypePath;
+
+export function parseContentTypePath(contentPath: string): ContentTypePath {
+    const contentPathArray = contentPath.split('/');
+    const typeOrPart = contentPathArray.shift();
+
+    if (!isTopicPart(typeOrPart) && !isContentType(typeOrPart)) {
+        throw createError({
+            status: 400,
+            statusMessage: `Invalid content path type/topic part: "${contentPath}"!`,
+        });
+    }
+
+    if (typeOrPart === 'topic') {
+        throw createError({
+            status: 400,
+            statusMessage: `Instead of "topic", use specific topic part (article, summary or practice) in content path: "${contentPath}"!`,
+        });
+    }
+
+    const fullOrShortId = contentPathArray.join('/');
+
+    if (!fullOrShortId) {
+        throw createError({
+            status: 400,
+            statusMessage: `Falsy content path full/short ID: "${contentPath}"!`,
+        });
+    }
+
+    if (isTopicPart(typeOrPart)) {
+        return {
+            type: 'topic',
+            topicPart: typeOrPart,
+            contentId: fullOrShortId,
+        };
+    }
+
+    return {
+        type: typeOrPart,
+        contentId: fullOrShortId,
+    };
+}
+
+export function stringifyContentTypePath(
+    typeOrPart: Omit<ContentType | TopicPart, 'topic'>,
+    fullOrShortId: string,
+): string {
+    return `${typeOrPart}/${fullOrShortId}`;
+}

package/shared/utils/icons.ts

@@ -0,0 +1,11 @@
+import type { MaybeMyIconName } from '#my-icons';
+
+export const ICONS = {
+    ['book']: 'book-outline',
+    ['group']: 'folder-open',
+    ['page']: 'lines',
+    ['topic']: 'array-lines',
+    ['article']: 'array-lines',
+    ['summary']: 'array-star',
+    ['practice']: 'array-check',
+} satisfies Record<string, MaybeMyIconName>;

package/shared/utils/pages.ts

@@ -0,0 +1,24 @@
+import type { TopicPart } from '@erudit-js/core/content/topic';
+
+export const PAGES = {
+    index: '/',
+    contributors: '/contributors/',
+    contributor: (contributorId?: string) => {
+        return slasher(`/contributor/${contributorId ?? ''}/`);
+    },
+    sponsors: '/sponsors/',
+    ['book']: (shortId: string) => {
+        return slasher(`/book/${shortId}/`);
+    },
+    ['group']: (shortId: string) => {
+        return slasher(`/group/${shortId}/`);
+    },
+    ['page']: (shortId: string, elementId?: string) => {
+        return slasher(`/page/${shortId}/${elementId ? '#' + elementId : ''}`);
+    },
+    ['topic']: (part: TopicPart, shortId: string, elementId?: string) => {
+        return slasher(
+            `/${part}/${shortId}/${elementId ? '#' + elementId : ''}`,
+        );
+    },
+};

package/shared/utils/slasher.ts

@@ -0,0 +1,64 @@
+interface SlasherOptions {
+    leading?: boolean;
+    trailing?: boolean;
+    dedupe?: boolean;
+    toForward?: boolean;
+}
+
+export function slasher(str: string, options: SlasherOptions = {}): string {
+    const opts: Required<Pick<SlasherOptions, 'toForward' | 'dedupe'>> &
+        SlasherOptions = {
+        toForward: true,
+        dedupe: true,
+        ...options,
+    };
+
+    let s = str ?? '';
+
+    // Normalize slashes direction
+    if (opts.toForward) {
+        s = s.replace(/\\/g, '/');
+    }
+
+    // Collapse runs of slashes, but preserve protocol double slashes (http://, https://, file://)
+    if (opts.dedupe) {
+        // Temporarily replace protocols to protect them
+        const protocolPlaceholder = '\x00PROTOCOL\x00';
+        const protocols: string[] = [];
+
+        s = s.replace(/(https?|file):\/\//g, (match) => {
+            protocols.push(match);
+            return protocolPlaceholder;
+        });
+
+        // Now dedupe slashes
+        s = s.replace(/\/{2,}/g, '/');
+
+        // Restore protocols
+        s = s.replace(
+            new RegExp(
+                protocolPlaceholder.replace(/[.*+?^${}()|[\]\\]/g, '\\$&'),
+                'g',
+            ),
+            () => protocols.shift()!,
+        );
+    }
+
+    // Leading slash handling
+    if (options?.leading === true) {
+        s = s.replace(/^\/+/, '');
+        s = '/' + s;
+    } else if (options?.leading === false) {
+        s = s.replace(/^\/+/, '');
+    }
+
+    // Trailing slash handling
+    if (options?.trailing === true) {
+        s = s.replace(/\/+$/, '');
+        s = s + '/';
+    } else if (options?.trailing === false) {
+        s = s.replace(/\/+$/, '');
+    }
+
+    return s;
+}

package/shared/utils/stringColor.ts

@@ -1,9 +1,13 @@
-export function stringColor(text: string) {
-    let hash = 0;
-
-    for (let i = 0; i < text.length; i++) {
-        hash = text.charCodeAt(i) + ((hash << 5) - hash);
-    }
-
-    return `hsl(${hash % 360}, 85%, 35%)`;
-}
+export function stringColor(text: string) {
+    let hash = 0;
+
+    for (let i = 0; i < text.length; i++) {
+        hash = text.charCodeAt(i) + ((hash << 5) - hash);
+    }
+
+    const hue = hash % 360;
+    const lightColor = `hsl(${hue}, 70%, 35%)`; // Darker for white background
+    const darkColor = `hsl(${hue}, 75%, 70%)`; // Lighter for black background
+
+    return `light-dark(${lightColor}, ${darkColor})`;
+}

package/shared/utils/toStringEqual.ts

@@ -0,0 +1,21 @@
+function stringifyValue(value: unknown): string {
+    if (value === null || typeof value !== 'object') {
+        return JSON.stringify(value);
+    }
+
+    if (Array.isArray(value)) {
+        return '[' + value.map(stringifyValue).join(',') + ']';
+    }
+
+    const obj = value as Record<string, unknown>;
+    const keys = Object.keys(obj).sort();
+    const props = keys.map(
+        (k) => JSON.stringify(k) + ':' + stringifyValue(obj[k]),
+    );
+
+    return '{' + props.join(',') + '}';
+}
+
+export function toStringEqual(a: unknown, b: unknown): boolean {
+    return stringifyValue(a) === stringifyValue(b);
+}

package/shared/utils/zip.ts

@@ -0,0 +1,64 @@
+export async function zip(text: string): Promise<string> {
+    const encoded = new TextEncoder().encode(text);
+    const compressedStream = new Blob([encoded.buffer as ArrayBuffer])
+        .stream()
+        .pipeThrough(new CompressionStream('gzip'));
+    const compressedBuffer = await new Response(compressedStream).arrayBuffer();
+
+    return toBase64(new Uint8Array(compressedBuffer));
+}
+
+export async function unzip(input: string): Promise<string> {
+    const gzBinary = fromBase64(input);
+    const decompressedStream = new Blob([gzBinary.buffer as ArrayBuffer])
+        .stream()
+        .pipeThrough(new DecompressionStream('gzip'));
+    const decompressedBuffer = await new Response(
+        decompressedStream,
+    ).arrayBuffer();
+
+    return new TextDecoder().decode(decompressedBuffer);
+}
+
+/**
+ * Convert Uint8Array to base64 safely in both browser and Node.
+ */
+function toBase64(bytes: Uint8Array): string {
+    if (typeof Buffer !== 'undefined') {
+        // Node environment
+        return Buffer.from(bytes).toString('base64');
+    }
+
+    if (typeof btoa !== 'undefined') {
+        // Browser environment
+        let binary = '';
+        const chunkSize = 0x8000;
+        for (let i = 0; i < bytes.length; i += chunkSize) {
+            binary += String.fromCharCode(...bytes.subarray(i, i + chunkSize));
+        }
+        return btoa(binary);
+    }
+
+    throw new Error('No base64 encoding function available.');
+}
+
+/**
+ * Convert base64 string to Uint8Array safely in both browser and Node.
+ */
+function fromBase64(b64: string): Uint8Array {
+    if (typeof Buffer !== 'undefined') {
+        // Node environment
+        return new Uint8Array(Buffer.from(b64, 'base64'));
+    }
+
+    if (typeof atob !== 'undefined') {
+        // Browser environment
+        const binary = atob(b64);
+        const len = binary.length;
+        const out = new Uint8Array(len);
+        for (let i = 0; i < len; i++) out[i] = binary.charCodeAt(i);
+        return out;
+    }
+
+    throw new Error('No base64 decoding function available.');
+}

package/test/shared/utils/slasher.test.ts

@@ -0,0 +1,75 @@
+import { describe, it, expect } from 'vitest';
+
+import { slasher } from '../../../shared/utils/slasher';
+
+describe('slasher', () => {
+    it('converts backslashes to forward slashes and dedupes by default', () => {
+        expect(slasher('a\\b\\\\c')).toBe('a/b/c');
+        expect(slasher('a////b//c')).toBe('a/b/c');
+    });
+
+    it('dedupes runs of slashes including leading and trailing by default', () => {
+        expect(slasher('///a////b//c///')).toBe('/a/b/c/');
+        expect(slasher('////')).toBe('/');
+        expect(slasher('/')).toBe('/');
+        expect(slasher('')).toBe('');
+    });
+
+    it('respects leading: true (ensure exactly one leading slash)', () => {
+        expect(slasher('a/b', { leading: true })).toBe('/a/b');
+        expect(slasher('///a/b', { leading: true })).toBe('/a/b');
+        expect(slasher('', { leading: true })).toBe('/');
+    });
+
+    it('respects leading: false (remove all leading slashes)', () => {
+        expect(slasher('///a/b', { leading: false })).toBe('a/b');
+        expect(slasher('/a', { leading: false })).toBe('a');
+    });
+
+    it('respects trailing: true (ensure exactly one trailing slash)', () => {
+        expect(slasher('a/b', { trailing: true })).toBe('a/b/');
+        expect(slasher('a/b///', { trailing: true })).toBe('a/b/');
+        expect(slasher('', { trailing: true })).toBe('/');
+    });
+
+    it('respects trailing: false (remove all trailing slashes)', () => {
+        expect(slasher('a/b///', { trailing: false })).toBe('a/b');
+        expect(slasher('/', { trailing: false })).toBe('');
+    });
+
+    it('respects toForward: false (do not convert backslashes)', () => {
+        expect(slasher('a\\b\\\\c', { toForward: false })).toBe('a\\b\\\\c');
+        // Forward slashes are still deduped by default
+        expect(slasher('a\\b//c', { toForward: false })).toBe('a\\b/c');
+    });
+
+    it('respects dedupe: false (keep multiple slashes)', () => {
+        expect(slasher('a////b//c', { dedupe: false })).toBe('a////b//c');
+        // Leading/trailing options still apply even when dedupe is false
+        expect(
+            slasher('///a////b//c///', {
+                leading: true,
+                trailing: true,
+                dedupe: false,
+            }),
+        ).toBe('/a////b//c/');
+    });
+
+    it('preserves protocol double slashes (http://, https://, file://)', () => {
+        expect(slasher('http://example.com/path')).toBe(
+            'http://example.com/path',
+        );
+        expect(slasher('https://example.com/path')).toBe(
+            'https://example.com/path',
+        );
+        expect(slasher('file://C:/path/to/file')).toBe(
+            'file://C:/path/to/file',
+        );
+        expect(slasher('http://example.com//path///to//resource')).toBe(
+            'http://example.com/path/to/resource',
+        );
+        expect(slasher('https://example.com/', { trailing: false })).toBe(
+            'https://example.com',
+        );
+    });
+});

package/test/shared/utils/zip.test.ts

@@ -0,0 +1,8 @@
+import { test, expect } from 'vitest';
+
+import { zip, unzip } from '../../../shared/utils/zip';
+
+test('zip/unzip', async () => {
+    const text = 'Hello мир 🌍!';
+    expect(await unzip(await zip(text))).toBe(text);
+});

package/tsconfig.json

@@ -1,8 +1,17 @@
-{
-    "extends": "../../playground/.erudit/nuxt/.nuxt/tsconfig.json",
-    "compilerOptions": {
-        "experimentalDecorators": true,
-        "emitDecoratorMetadata": true,
-        "types": ["@types/jest", "@erudit-js/cog/types"]
-    }
-}
+{
+    "files": [],
+    "references": [
+        {
+            "path": "../../playground/.erudit/nuxt/.nuxt/tsconfig.server.json"
+        },
+        {
+            "path": "../../playground/.erudit/nuxt/.nuxt/tsconfig.app.json"
+        },
+        {
+            "path": "../../playground/.erudit/nuxt/.nuxt/tsconfig.shared.json"
+        },
+        {
+            "path": "../../playground/.erudit/nuxt/.nuxt/tsconfig.node.json"
+        }
+    ]
+}

package/app/assets/icons/alert.svg

@@ -1,3 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
-    <path d="M1.4,22.3c-.2,0-.4,0-.6-.2-.2-.1-.3-.2-.4-.4s-.1-.4-.2-.6,0-.4.2-.6L11,2.3c.1-.2.3-.3.4-.4s.4-.1.6-.1.4,0,.6.1.3.2.4.4l10.6,18.3c.1.2.2.4.2.6s0,.4-.2.6-.2.3-.4.4c-.2.1-.4.2-.6.2H1.4ZM3.4,20h17.3L12,5.1,3.4,20ZM12,18.9c.3,0,.6-.1.8-.3.2-.2.3-.5.3-.8s-.1-.6-.3-.8c-.2-.2-.5-.3-.8-.3s-.6.1-.8.3-.3.5-.3.8.1.6.3.8c.2.2.5.3.8.3ZM12,15.4c.3,0,.6-.1.8-.3.2-.2.3-.5.3-.8v-3.4c0-.3-.1-.6-.3-.8-.2-.2-.5-.3-.8-.3s-.6.1-.8.3-.3.5-.3.8v3.4c0,.3.1.6.3.8s.5.3.8.3Z"/>
-</svg>

package/app/assets/icons/angle-right.svg

@@ -1,3 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 246 512">
-    <path d="M225.7,233.4c12.5,12.5,12.5,32.8,0,45.3l-160,160c-12.5,12.5-32.8,12.5-45.3,0s-12.5-32.8,0-45.3l137.4-137.4L20.4,118.6c-12.5-12.5-12.5-32.8,0-45.3s32.8-12.5,45.3,0l160,160h-.1Z"/>
-</svg>

package/app/assets/icons/arrow-in-text.svg

@@ -1,3 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
-    <path d="M10.2,17.6h5v-2.5h-5v2.5ZM10.2,12.6h8.7v-2.5h-8.7v2.5ZM6.5,7.7h12.4v-2.5H6.5v2.5ZM6,23.8c-1.6,0-3-.6-4.2-1.7S.1,19.5.1,17.9s.3-2.2.9-3.2,1.4-1.6,2.4-2.1H.3v-2.5h7.5v7.5h-2.5v-3c-.8.2-1.4.6-1.9,1.2s-.7,1.3-.7,2.1.3,1.8,1,2.4,1.5,1,2.4,1v2.5ZM10.2,22.6v-2.5h11.2V2.7H4v5H1.5V2.7c0-.7.2-1.3.7-1.8.5-.5,1.1-.7,1.8-.7h17.4c.7,0,1.3.2,1.8.7s.7,1.1.7,1.8v17.4c0,.7-.2,1.3-.7,1.8-.5.5-1.1.7-1.8.7h-11.2Z"/>
-</svg>

package/app/assets/icons/arrow-left.svg

@@ -1,3 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 448 512">
-    <path d="M9.4 233.4c-12.5 12.5-12.5 32.8 0 45.3l160 160c12.5 12.5 32.8 12.5 45.3 0s12.5-32.8 0-45.3L109.2 288 416 288c17.7 0 32-14.3 32-32s-14.3-32-32-32l-306.7 0L214.6 118.6c12.5-12.5 12.5-32.8 0-45.3s-32.8-12.5-45.3 0l-160 160z" />
-</svg>

package/app/assets/icons/arrow-up-to-right.svg

@@ -1,3 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 512 512">
-    <path d="M334.5,430c8.8,3.8,19,2,26-4.6l144-136c4.8-4.5,7.5-10.8,7.5-17.4s-2.7-12.9-7.5-17.4l-144-136c-7-6.6-17.2-8.4-26-4.6-8.8,3.8-14.5,12.5-14.5,22v88h-192c-17.7,0-32-14.3-32-32v-80c0-17.7-14.3-32-32-32h-32C14.3,80,0,94.3,0,112v80c0,70.7,57.3,128,128,128h192s0,88,0,88c0,9.6,5.7,18.2,14.5,22Z"/>
-</svg>

package/app/assets/icons/chip.svg

@@ -1,3 +0,0 @@
-<svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24">
-    <path d="M8.1,15.9v-7.9h7.9v7.9h-7.9ZM10.7,13.3h2.6v-2.6h-2.6v2.6ZM8.1,23.8v-2.6h-2.6c-.7,0-1.3-.3-1.9-.8s-.8-1.1-.8-1.9v-2.6H.2v-2.6h2.6v-2.6H.2v-2.6h2.6v-2.6c0-.7.3-1.3.8-1.9s1.1-.8,1.9-.8h2.6V.2h2.6v2.6h2.6V.2h2.6v2.6h2.6c.7,0,1.3.3,1.9.8s.8,1.1.8,1.9v2.6h2.6v2.6h-2.6v2.6h2.6v2.6h-2.6v2.6c0,.7-.3,1.3-.8,1.9s-1.1.8-1.9.8h-2.6v2.6h-2.6v-2.6h-2.6v2.6h-2.6ZM18.6,18.6V5.4H5.4v13.1h13.1Z"/>
-</svg>