@oceanum/oceanumlab 4.6.0

package/src/notebookContext.ts

@@ -0,0 +1,144 @@
+import type { Notebook } from '@jupyterlab/notebook';
+
+/**
+ * A notebook cell reduced to what the chat context needs.
+ */
+export interface IContextCell {
+  kind: 'code' | 'markdown';
+  source: string;
+}
+
+/** What a request carries from the conversation's notebook. */
+export interface INotebookSnapshot {
+  cells: IContextCell[];
+  /** The selected cell, which a code answer may replace. None when closed. */
+  selected: { source: string; isCode: boolean } | null;
+}
+
+// Mirrors oceanum-ai's app/config.py. Past either limit the server rejects the
+// whole request, so the chat fails outright rather than losing some context.
+export const MAX_NOTEBOOK_CELLS = 500;
+export const MAX_CELL_CHARS = 100000;
+
+// The server also caps the WHOLE request body at 2 MiB (MAX_REQUEST_BYTES),
+// and that body carries chat history and, on follow-up rounds, run outputs as
+// well as the cells. Markdown may take the cells up to half of it.
+export const MAX_CELLS_BYTES = 1024 * 1024;
+
+// An inline image: the one thing in markdown that is routinely huge. Any media
+// type, any `;param` or `;param=value` (charset, base64, utf8), then the data
+// up to the first space, bracket or quote.
+const DATA_URI =
+  /data:[\w.+-]+\/[\w.+-]+(?:;[\w.+-]+(?:=[\w.+-]+)?)*,[^\s)"']+/g;
+
+/** An open notebook's code and markdown cells, and its selected cell. */
+export function snapshotOf(notebook: Notebook): INotebookSnapshot {
+  const cells: IContextCell[] = [];
+  for (const cell of notebook.widgets) {
+    const type = cell.model.type;
+    if (type === 'code' || type === 'markdown') {
+      cells.push({ kind: type, source: cell.model.sharedModel.getSource() });
+    }
+  }
+  const active = notebook.activeCell;
+  return {
+    cells,
+    selected: active
+      ? {
+          source: active.model.sharedModel.getSource(),
+          isCode: active.model.type === 'code'
+        }
+      : null
+  };
+}
+
+/**
+ * A closed notebook's cells, read from its file.
+ *
+ * Read rather than opened again: re-opening the tab is for an answer with
+ * cells to place, not for asking a question. A closed notebook has no
+ * selected cell. Anything unexpected in the file reads as no cells rather
+ * than an error -- context is best-effort.
+ */
+export function snapshotFromIpynb(content: unknown): INotebookSnapshot {
+  const raw = (content as { cells?: unknown } | null)?.cells;
+  const cells: IContextCell[] = [];
+  if (Array.isArray(raw)) {
+    for (const cell of raw) {
+      const { cell_type: type, source } = (cell ?? {}) as {
+        cell_type?: unknown;
+        source?: unknown;
+      };
+      if (type !== 'code' && type !== 'markdown') {
+        continue;
+      }
+      // nbformat allows the source as one string or as a list of lines.
+      const text = Array.isArray(source)
+        ? source.join('')
+        : typeof source === 'string'
+          ? source
+          : '';
+      cells.push({ kind: type, source: text });
+    }
+  }
+  return { cells, selected: null };
+}
+
+/**
+ * The notebook as `notebookCells`: every non-empty code and markdown cell, in
+ * order.
+ *
+ * The server renders all of them inside ONE ```python block, each headed
+ * `# Cell N`, so markdown sent raw would read there as broken code. It goes as
+ * comment lines under a jupytext-style `# %% [markdown]` marker instead: still
+ * valid Python, and unambiguous to the model.
+ *
+ * Markdown is also what can push a request past the server's limits, and those
+ * reject the whole request -- costing the user the chat for the sake of some
+ * prose. So markdown gives way first: inline images are dropped from it, an
+ * oversized markdown cell is left out, and when the markdown would take the
+ * cells past the server's cell count or past MAX_CELLS_BYTES, only the code is
+ * sent -- which is what was sent before markdown was included.
+ */
+export function formatNotebookCells(cells: readonly IContextCell[]): string[] {
+  const code: string[] = [];
+  const all: string[] = [];
+  for (const cell of cells) {
+    if (!cell.source.trim()) {
+      continue;
+    }
+    if (cell.kind === 'code') {
+      code.push(cell.source);
+      all.push(cell.source);
+      continue;
+    }
+    const markdown = asMarkdownComment(cell.source);
+    if (markdown.length <= MAX_CELL_CHARS) {
+      all.push(markdown);
+    }
+  }
+  if (all.length > MAX_NOTEBOOK_CELLS || totalBytes(all) > MAX_CELLS_BYTES) {
+    return code;
+  }
+  return all;
+}
+
+function asMarkdownComment(source: string): string {
+  const lines = source
+    .replace(DATA_URI, 'data:…')
+    .split(/\r?\n/)
+    .map(line => (line ? `# ${line}` : '#'));
+  return ['# %% [markdown]', ...lines].join('\n');
+}
+
+/** UTF-8 size, which is what the server's byte limit counts. */
+function totalBytes(texts: readonly string[]): number {
+  let bytes = 0;
+  for (const text of texts) {
+    for (const char of text) {
+      const point = char.codePointAt(0) ?? 0;
+      bytes += point < 0x80 ? 1 : point < 0x800 ? 2 : point < 0x10000 ? 3 : 4;
+    }
+  }
+  return bytes;
+}

package/src/notebookHost.ts

@@ -0,0 +1,97 @@
+import type { JupyterFrontEnd } from '@jupyterlab/application';
+import type { INotebookTracker } from '@jupyterlab/notebook';
+import { NotebookPanel } from '@jupyterlab/notebook';
+import type { INotebookHost } from './conversationPin';
+
+// Longest wait for a notebook to open, be created, or load. The pin takes one
+// step at a time, so a step that never finished would stall every chat.
+export const NOTEBOOK_WAIT_MS = 15000;
+
+/** `promise`, or null if it fails or has not settled within `ms`. */
+function within<T>(promise: Promise<T>, ms: number): Promise<T | null> {
+  return new Promise<T | null>(resolve => {
+    const timer = setTimeout(() => resolve(null), ms);
+    promise.then(
+      value => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      () => {
+        clearTimeout(timer);
+        resolve(null);
+      }
+    );
+  });
+}
+
+/**
+ * The notebook a command opened, once its contents have loaded; null if the
+ * command opened something else, or either step failed or took over `ms`.
+ *
+ * `docmanager:open` and `notebook:create-new` hand back the panel before the
+ * file has been read, and reading it REPLACES every cell: an answer placed
+ * before then is wiped when the file arrives.
+ */
+async function loaded(
+  opened: Promise<unknown>,
+  ms: number
+): Promise<NotebookPanel | null> {
+  const widget = await within(opened, ms);
+  if (!(widget instanceof NotebookPanel)) {
+    return null;
+  }
+  return within(
+    widget.context.ready.then(() => widget),
+    ms
+  );
+}
+
+/** JupyterLab as ConversationPin sees it. */
+export function notebookHost(
+  app: JupyterFrontEnd,
+  tracker: INotebookTracker,
+  waitMs = NOTEBOOK_WAIT_MS
+): INotebookHost {
+  return {
+    // `app.shell` tracks only main-area tabs, so its current widget is the
+    // active tab even while focus is in the sidebar.
+    activeTab: () => {
+      const widget = app.shell.currentWidget;
+      return widget && tracker.has(widget) ? (widget as NotebookPanel) : null;
+    },
+    // A new Python 3 notebook, made the active tab. `notebook:create-new`
+    // returns the panel it opens; anything else is a failure. Taking the next
+    // notebook to appear instead could take one the user opened meanwhile.
+    create: async () => {
+      const panel = await loaded(
+        app.commands.execute('notebook:create-new', { kernelName: 'python3' }),
+        waitMs
+      );
+      if (panel) {
+        app.shell.activateById(panel.id);
+      }
+      return panel;
+    },
+    // Null when the file has been deleted, or has gone some other way: a new
+    // notebook then takes over.
+    reopen: async path => {
+      // Opened again by the user already: theirs, selection and all.
+      const open = tracker.find(panel => panel.context.path === path);
+      if (open) {
+        return loaded(Promise.resolve(open), waitMs);
+      }
+      const panel = await loaded(
+        app.commands.execute('docmanager:open', { path }),
+        waitMs
+      );
+      if (panel) {
+        // It opens with its first cell selected, which nobody chose, and
+        // answers go below the selected cell: above all the user's work.
+        // Select the last cell, so they go at the end.
+        panel.content.activeCellIndex = panel.content.widgets.length - 1;
+      }
+      return panel;
+    },
+    activate: panel => app.shell.activateById(panel.id)
+  };
+}

package/src/notebookRun.ts

@@ -0,0 +1,104 @@
+import type * as nbformat from '@jupyterlab/nbformat';
+
+/**
+ * What one code cell did when it ran, in the shape `/api/chat/observe` takes.
+ *
+ * The notebook counterpart of the sandbox's ExecResult. `message` is the
+ * agent's own explanation for the response that carried this code, so a
+ * capped final answer can say what the whole chain was doing.
+ */
+export interface ObservedRun {
+  code: string;
+  status: 'ok' | 'error';
+  stdout: string;
+  error: string | null;
+  message: string;
+}
+
+/** The part of a run the kernel decides; what `harvestOutputs` reads off it. */
+export type RunOutcome = Pick<ObservedRun, 'status' | 'stdout' | 'error'>;
+
+/**
+ * Most text kept per field. The server reads only the tail of stdout and a
+ * bounded traceback (OBSERVATION_STDOUT_CHARS), and every observe request
+ * re-sends every run so far, so anything past this is bytes shipped for
+ * nothing -- a cell printing in a loop can produce megabytes.
+ */
+export const MAX_OBSERVED_CHARS = 8000;
+
+// CSI (colour, cursor, including private-mode `?25l` from progress bars) and
+// OSC (titles, hyperlinks) sequences, per ECMA-48. An OSC body cannot contain
+// ESC, so the body class excludes it: otherwise an ST-terminated OSC followed
+// later by a BEL-terminated one would swallow the text between them.
+const ANSI =
+  // eslint-disable-next-line no-control-regex
+  /\u001b\[[0-?]*[ -/]*[@-~]|\u001b\][^\u0007\u001b]*(?:\u0007|\u001b\\)/g;
+
+/** Kernel tracebacks are coloured for a terminal; the model does not need that. */
+export function stripAnsi(text: string): string {
+  return text.replace(ANSI, '');
+}
+
+/** Keep the end: that is where the summary line, or the raised error, is. */
+function tail(text: string): string {
+  if (text.length <= MAX_OBSERVED_CHARS) {
+    return text;
+  }
+  return `…[${text.length - MAX_OBSERVED_CHARS} chars truncated]\n${text.slice(
+    -MAX_OBSERVED_CHARS
+  )}`;
+}
+
+function asText(value: nbformat.MultilineString | undefined): string {
+  if (value === undefined) {
+    return '';
+  }
+  return Array.isArray(value) ? value.join('') : value;
+}
+
+/**
+ * Reduce a cell's outputs to what the observation prompt needs.
+ *
+ * Stream stdout is concatenated in order. An `error` output makes the run an
+ * error and its traceback the error text; the kernel's stderr stream is folded
+ * in after it, because warnings there are often the useful part of a failure.
+ * Rendered outputs (execute_result, display_data) are deliberately NOT sent:
+ * a DataFrame repr is kilobytes of dataset-derived text, and the agent gets
+ * the printed summary the code chose to make instead.
+ */
+export function harvestOutputs(
+  outputs: readonly nbformat.IOutput[]
+): RunOutcome {
+  const stdout: string[] = [];
+  const stderr: string[] = [];
+  let error: string | null = null;
+
+  for (const output of outputs) {
+    if (nbformatIsStream(output)) {
+      (output.name === 'stderr' ? stderr : stdout).push(asText(output.text));
+    } else if (nbformatIsError(output)) {
+      const traceback = stripAnsi(output.traceback.join('\n'));
+      error = `${output.ename}: ${output.evalue}\n${traceback}`.trim();
+    }
+  }
+
+  if (error !== null && stderr.length > 0) {
+    error = `${error}\n${stripAnsi(stderr.join(''))}`.trim();
+  }
+
+  return {
+    status: error === null ? 'ok' : 'error',
+    stdout: tail(stripAnsi(stdout.join(''))),
+    error: error === null ? null : tail(error)
+  };
+}
+
+function nbformatIsStream(
+  output: nbformat.IOutput
+): output is nbformat.IStream {
+  return output.output_type === 'stream';
+}
+
+function nbformatIsError(output: nbformat.IOutput): output is nbformat.IError {
+  return output.output_type === 'error';
+}

package/src/progress.ts

@@ -0,0 +1,121 @@
+/**
+ * What the agent is doing right now, from the extension host to the widget
+ * (OCE-175).
+ *
+ * A channel is needed because the widget does not call the router: it issues
+ * the `oceanum-ai:submit-prompt` COMMAND, and command arguments must be JSON,
+ * so a callback cannot cross. The Stop button has the same constraint and
+ * solves it the same way -- an AbortController held in the plugin's closure.
+ *
+ * A module singleton rather than a JupyterLab `Signal`, because a Signal wants
+ * an owner object and there is no natural one here: the producer is a command
+ * handler and the consumer is a React component that mounts and unmounts
+ * independently of it.
+ */
+
+/** A phase the backend named, and the tool it is using if that is the phase. */
+export interface Progress {
+  phase: string;
+  tool?: string;
+}
+
+type Listener = (progress: Progress | null) => void;
+
+const listeners = new Set<Listener>();
+
+/** Subscribe. Returns the unsubscribe, for a React effect's cleanup. */
+export function onProgress(listener: Listener): () => void {
+  listeners.add(listener);
+  return () => {
+    listeners.delete(listener);
+  };
+}
+
+/**
+ * Publish. `null` means "no longer working", which the widget uses to fall
+ * back to its own wording rather than leaving the last phase on screen after
+ * the answer has arrived.
+ *
+ * A listener that throws must not stop the others hearing, nor break the
+ * request: this is decoration, and a broken indicator is not worth failing an
+ * answer over.
+ */
+export function reportProgress(progress: Progress | null): void {
+  for (const listener of listeners) {
+    try {
+      listener(progress);
+    } catch (err) {
+      console.error('Oceanum AI: a progress listener threw', err);
+    }
+  }
+}
+
+/**
+ * A reporter for one run: it publishes only while `isCurrent()` holds.
+ *
+ * A run that New chat or a newer prompt replaced is aborted, but it can take a
+ * while to unwind -- a cell that ignores the interrupt keeps it in its handoff
+ * -- and whatever it reports on the way out, a phase or its "no longer
+ * working", would land on the new run's progress line.
+ */
+export function reporterFor(
+  isCurrent: () => boolean
+): (progress: Progress | null) => void {
+  return progress => {
+    if (isCurrent()) {
+      reportProgress(progress);
+    }
+  };
+}
+
+/**
+ * What each phase is, in the user's terms.
+ *
+ * An unlisted phase or tool falls back to something generic rather than
+ * showing its internal name: a new server-side tool should read as progress,
+ * not as a leak of what the agent is made of. And no phase at all reads as
+ * "Thinking…", which is what this said before there was anything better to
+ * say -- so a backend that does not stream, or a proxy that buffered the
+ * stream away, degrades to exactly the old behaviour rather than to a blank.
+ */
+const TOOL_LABELS: Record<string, string> = {
+  search_catalog: 'Searching the catalogue…',
+  get_datasource_info: 'Reading dataset details…',
+  save_memory: 'Saving a note…'
+};
+
+const PHASE_LABELS: Record<string, string> = {
+  generating: 'Thinking…',
+  interpreting: 'Reading the result…',
+  // Reported by the client, not the server: these two are the notebook's turn.
+  // Everything else here names something the agent is doing, and saying so
+  // while a cell runs would be actively false rather than merely vague.
+  running: 'Running the code…',
+  placing: 'Adding the code to the notebook…'
+};
+
+export function describeProgress(progress: Progress | null): string {
+  if (!progress) {
+    return 'Thinking…';
+  }
+  if (progress.phase === 'tool') {
+    return labelFor(TOOL_LABELS, progress.tool) ?? 'Looking something up…';
+  }
+  return labelFor(PHASE_LABELS, progress.phase) ?? 'Working…';
+}
+
+/**
+ * The label `labels` itself gives `name`, if any. Only its own entries: the
+ * name comes off the stream -- a tool name is whatever the model called -- and
+ * `__proto__` or `toString` must not reach into Object.prototype. That hands
+ * React an object or a function to render, and an object breaks the panel.
+ */
+function labelFor(
+  labels: Record<string, string>,
+  name: string | undefined
+): string | undefined {
+  return name !== undefined &&
+    Object.prototype.hasOwnProperty.call(labels, name)
+    ? labels[name]
+    : undefined;
+}

package/src/sse.ts

@@ -0,0 +1,127 @@
+/**
+ * Reading a Server-Sent Events body (OCE-175).
+ *
+ * Small and local rather than a dependency: SSE is a line format, the backend
+ * emits one `data:` line per event, and a library would bring a parser for the
+ * multi-line and retry-directive cases this stream does not use.
+ *
+ * Note it is NOT `EventSource`. That only issues GETs, and these are POSTs with
+ * a body and an auth header, which is why every client of this API hand-rolls
+ * the read.
+ */
+
+/** One frame off the wire. `data` is raw; the caller parses it. */
+export interface SseEvent {
+  event: string;
+  data: string;
+  id?: string;
+}
+
+/**
+ * Yield each event as it arrives.
+ *
+ * Decodes with `stream: true` so a multi-byte character split across two
+ * network chunks is reassembled rather than mangled -- a UTF-8 sequence has no
+ * obligation to arrive whole, and a dataset name with an accent in it is the
+ * kind of thing that finds this bug in production rather than in a test.
+ */
+export async function* readSse(
+  body: ReadableStream<Uint8Array>,
+  signal?: AbortSignal
+): AsyncGenerator<SseEvent> {
+  const reader = body.getReader();
+  const decoder = new TextDecoder();
+  let buffer = '';
+
+  /** Every complete frame currently in the buffer. Events are separated by a
+   * blank line; anything after the last one is partial and stays put. */
+  function* drain(): Generator<SseEvent> {
+    let split = buffer.indexOf('\n\n');
+    while (split !== -1) {
+      const frame = buffer.slice(0, split);
+      buffer = buffer.slice(split + 2);
+      const parsed = parseFrame(frame);
+      if (parsed) {
+        yield parsed;
+      }
+      split = buffer.indexOf('\n\n');
+    }
+  }
+
+  try {
+    while (true) {
+      if (signal?.aborted) {
+        return;
+      }
+      const { done, value } = await reader.read();
+      if (done) {
+        // Flush the deferred `\r`, if any: no further chunk is coming, so it
+        // cannot be half of a CRLF and IS a line ending. Without this a stream
+        // using bare CR loses its final frame -- the terminator never forms.
+        buffer = normaliseNewlines(buffer, true);
+        yield* drain();
+        break;
+      }
+      buffer = normaliseNewlines(
+        buffer + decoder.decode(value, { stream: true })
+      );
+      yield* drain();
+    }
+  } finally {
+    // Releases the reader's lock whether the consumer finished, threw, or
+    // stopped early -- a `break` in a for-await runs this. It does not cancel
+    // the body: the backend ends the stream after `done` or `error`, and Stop's
+    // abort closes the connection itself.
+    reader.releaseLock();
+  }
+}
+
+/**
+ * Collapse CRLF and bare CR to LF, so the rest of the parser can look for a
+ * single line ending.
+ *
+ * The spec allows all three, and our own backend sends LF -- but "our backend
+ * sends LF" is a statement about one hop. Anything between it and the browser
+ * may rewrite line endings, and the failure if it does is total rather than
+ * partial: the frame separator `\n\n` never matches `\r\n\r\n`, so ZERO events
+ * parse, the stream looks empty, and the caller reports the response as
+ * incomplete. Measured before this existed: 0 events from a well-formed CRLF
+ * stream.
+ *
+ * The trailing `\r` is held back, and that is the whole subtlety. A chunk may
+ * end mid-CRLF, with the `\n` arriving next; converting that `\r` to `\n` now
+ * and meeting its partner later would manufacture a blank line -- a frame
+ * boundary that was never sent, splitting one event into two malformed ones.
+ * So it waits for the next chunk, exactly as a split multi-byte character does.
+ */
+function normaliseNewlines(buffer: string, final = false): string {
+  const held = !final && buffer.endsWith('\r') ? '\r' : '';
+  const body = held ? buffer.slice(0, -1) : buffer;
+  return body.replace(/\r\n/g, '\n').replace(/\r/g, '\n') + held;
+}
+
+function parseFrame(frame: string): SseEvent | null {
+  let event = 'message';
+  let id: string | undefined;
+  const data: string[] = [];
+
+  for (const line of frame.split('\n')) {
+    // A comment. The backend sends these as keepalives during a long wait, and
+    // they carry nothing.
+    if (line.startsWith(':')) {
+      continue;
+    }
+    if (line.startsWith('event:')) {
+      event = line.slice('event:'.length).trim();
+    } else if (line.startsWith('data:')) {
+      data.push(line.slice('data:'.length).trim());
+    } else if (line.startsWith('id:')) {
+      id = line.slice('id:'.length).trim();
+    }
+  }
+
+  if (data.length === 0) {
+    return null;
+  }
+  return { event, data: data.join('\n'), id };
+}

package/src/svg.d.ts

@@ -0,0 +1,4 @@
+declare module '*.svg' {
+  const image: string;
+  export default image;
+}

package/style/base.css

@@ -0,0 +1,5 @@
+/*
+    See the JupyterLab Developer Guide for useful CSS Patterns:
+
+    https://jupyterlab.readthedocs.io/en/stable/developer/css.html
+*/

package/style/icons/oceanum-dark.svg

@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8"?><svg id="Layer_2" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 76.5997 76.5918"><g id="Components"><g id="_x32_9414058-301b-4d05-be55-13a1e0a9aa73_x40_13"><path d="M50.9806,74.333c-3.3558,1.2907-7.8269,2.2589-12.7127,2.2589s-9.293-.9681-12.6489-2.2589c1.0973-.5806,2.2585-1.1615,3.4204-1.6779,2.9036-1.2903,5.9372-2.3877,9.2285-2.3877s6.3886,1.0973,9.2923,2.3877c1.1611.5164,2.3231,1.0973,3.4204,1.6779Z" style="fill:#aadde1;"/><path d="M38.268,0C17.1658,0,0,17.1654,0,38.3322c0,.9032.0638,1.8713.1284,2.7748.1292,2.2585.4522,4.3881,1.0335,6.5178,1.6133.7098,3.162,1.2257,4.6461,1.6133.9028.258,1.8071.3872,2.6453.3872,1.6133.1288,3.162,0,4.7753-.3872,2.453-.581,5.0337-1.6779,7.6151-2.9686,2.5814-1.2261,5.3559-2.7748,8.1957-4.0656,2.9036-1.2907,5.9372-2.3877,9.2285-2.3877s6.3886,1.0969,9.2923,2.3877c2.839,1.2907,5.5497,2.8394,8.1957,4.0656,2.5807,1.2907,5.0983,2.3877,7.6144,2.9686,1.6133.3872,3.2266.516,4.8399.3872.839-.0646,1.7425-.1938,2.5814-.3872,1.4841-.3876,3.0336-.9035,4.6469-1.6133.5152-2.1297.9028-4.2593,1.0319-6.5178.0646-.9035.1292-1.8717.1292-2.7748C76.5997,17.1654,59.4339,0,38.268,0Z" style="fill:#aadde1;"/><path d="M72.8563,54.7153c-1.1611,2.5169-2.5807,4.8399-4.3232,6.9696-1.7425.1934-3.4204.1288-5.1629-.2584-2.5161-.6452-5.0337-1.6779-7.6144-2.9682-2.646-1.2907-5.3567-2.7748-8.1957-4.0656-2.9036-1.2907-6.0011-2.3877-9.2923-2.3877s-6.3248,1.0969-9.2285,2.3877c-2.8398,1.2907-5.6143,2.7748-8.1957,4.0656-2.5814,1.2903-5.1621,2.3231-7.6151,2.9682-1.7425.3872-3.4204.4518-5.1621.2584-1.7425-2.1297-3.2266-4.4527-4.3885-6.9696.7105.1934,1.4195.3872,2.1301.5806,2.4515.581,4.9045.581,7.4206,0,2.453-.5806,5.0337-1.6133,7.6151-2.9036,2.5814-1.2907,5.3559-2.8394,8.1957-4.0656,2.9036-1.2907,5.9372-2.3877,9.2285-2.3877s6.3886,1.0969,9.2923,2.3877c2.839,1.2261,5.5497,2.7748,8.1957,4.0656,2.5807,1.2903,5.0983,2.3231,7.6144,2.9036,2.4523.581,4.9045.581,7.4214,0,.6452-.1288,1.3557-.3226,2.0647-.5806Z" style="fill:#aadde1;"/><path d="M63.1119,67.428c-1.7425,1.5491-3.678,2.904-5.7427,4.001-.5168-.258-1.0973-.516-1.6133-.7744-2.646-1.2903-5.3567-2.7748-8.1957-4.0656-2.9036-1.2903-6.0011-2.3877-9.2923-2.3877s-6.3248,1.0973-9.2285,2.3877c-2.8398,1.2907-5.6143,2.7752-8.1957,4.0656-.516.2584-1.0973.5164-1.6133.7744-2.0647-1.0969-4.001-2.4519-5.7435-4.001,2.3877-.5806,4.8399-1.6775,7.3568-2.8394,2.5814-1.2903,5.3559-2.8394,8.1957-4.1298,2.9036-1.2907,5.9372-2.3877,9.2285-2.3877s6.3886,1.0969,9.2923,2.3877c2.839,1.2903,5.5497,2.8394,8.1957,4.1298,2.5161,1.1619,4.9045,2.2589,7.356,2.8394Z" style="fill:#aadde1;"/></g></g></svg>

package/style/icons/oceanum-light.svg

@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8"?><svg id="Layer_2" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 76.5997 76.5918"><g id="Components"><g id="_x32_9414058-301b-4d05-be55-13a1e0a9aa73_x40_1"><path d="M50.9806,74.333c-3.3558,1.2907-7.8269,2.2589-12.7127,2.2589s-9.293-.9681-12.6489-2.2589c1.0973-.5806,2.2585-1.1615,3.4204-1.6779,2.9036-1.2903,5.9372-2.3877,9.2285-2.3877s6.3886,1.0973,9.2923,2.3877c1.1611.5164,2.3231,1.0973,3.4204,1.6779Z" style="fill:#0b2d40;"/><path d="M38.268,0C17.1658,0,0,17.1654,0,38.3322c0,.9032.0638,1.8713.1284,2.7748.1292,2.2585.4522,4.3881,1.0335,6.5178,1.6133.7098,3.162,1.2257,4.6461,1.6133.9028.258,1.8071.3872,2.6453.3872,1.6133.1288,3.162,0,4.7753-.3872,2.453-.581,5.0337-1.6779,7.6151-2.9686,2.5814-1.2261,5.3559-2.7748,8.1957-4.0656,2.9036-1.2907,5.9372-2.3877,9.2285-2.3877s6.3886,1.0969,9.2923,2.3877c2.839,1.2907,5.5497,2.8394,8.1957,4.0656,2.5807,1.2907,5.0983,2.3877,7.6144,2.9686,1.6133.3872,3.2266.516,4.8399.3872.839-.0646,1.7425-.1938,2.5814-.3872,1.4841-.3876,3.0336-.9035,4.6469-1.6133.5152-2.1297.9028-4.2593,1.0319-6.5178.0646-.9035.1292-1.8717.1292-2.7748C76.5997,17.1654,59.4339,0,38.268,0Z" style="fill:#0b2d40;"/><path d="M72.8563,54.7153c-1.1611,2.5169-2.5807,4.8399-4.3232,6.9696-1.7425.1934-3.4204.1288-5.1629-.2584-2.5161-.6452-5.0337-1.6779-7.6144-2.9682-2.646-1.2907-5.3567-2.7748-8.1957-4.0656-2.9036-1.2907-6.0011-2.3877-9.2923-2.3877s-6.3248,1.0969-9.2285,2.3877c-2.8398,1.2907-5.6143,2.7748-8.1957,4.0656-2.5814,1.2903-5.1621,2.3231-7.6151,2.9682-1.7425.3872-3.4204.4518-5.1621.2584-1.7425-2.1297-3.2266-4.4527-4.3885-6.9696.7105.1934,1.4195.3872,2.1301.5806,2.4515.581,4.9045.581,7.4206,0,2.453-.5806,5.0337-1.6133,7.6151-2.9036,2.5814-1.2907,5.3559-2.8394,8.1957-4.0656,2.9036-1.2907,5.9372-2.3877,9.2285-2.3877s6.3886,1.0969,9.2923,2.3877c2.839,1.2261,5.5497,2.7748,8.1957,4.0656,2.5807,1.2903,5.0983,2.3231,7.6144,2.9036,2.4523.581,4.9045.581,7.4214,0,.6452-.1288,1.3557-.3226,2.0647-.5806Z" style="fill:#0b2d40;"/><path d="M63.1119,67.428c-1.7425,1.5491-3.678,2.904-5.7427,4.001-.5168-.258-1.0973-.516-1.6133-.7744-2.646-1.2903-5.3567-2.7748-8.1957-4.0656-2.9036-1.2903-6.0011-2.3877-9.2923-2.3877s-6.3248,1.0973-9.2285,2.3877c-2.8398,1.2907-5.6143,2.7752-8.1957,4.0656-.516.2584-1.0973.5164-1.6133.7744-2.0647-1.0969-4.001-2.4519-5.7435-4.001,2.3877-.5806,4.8399-1.6775,7.3568-2.8394,2.5814-1.2903,5.3559-2.8394,8.1957-4.1298,2.9036-1.2907,5.9372-2.3877,9.2285-2.3877s6.3886,1.0969,9.2923,2.3877c2.839,1.2903,5.5497,2.8394,8.1957,4.1298,2.5161,1.1619,4.9045,2.2589,7.356,2.8394Z" style="fill:#0b2d40;"/></g></g></svg>

package/style/icons/oceanum.svg

@@ -0,0 +1 @@
+<?xml version="1.0" encoding="UTF-8"?><svg id="Layer_2" xmlns="http://www.w3.org/2000/svg" viewBox="0 0 76.5997 76.5918"><g id="Components"><g id="_x32_9414058-301b-4d05-be55-13a1e0a9aa73_x40_1"><path d="M50.9806,74.333c-3.3558,1.2907-7.8269,2.2589-12.7127,2.2589s-9.293-.9681-12.6489-2.2589c1.0973-.5806,2.2585-1.1615,3.4204-1.6779,2.9036-1.2903,5.9372-2.3877,9.2285-2.3877s6.3886,1.0973,9.2923,2.3877c1.1611.5164,2.3231,1.0973,3.4204,1.6779Z" fill="currentColor"/><path d="M38.268,0C17.1658,0,0,17.1654,0,38.3322c0,.9032.0638,1.8713.1284,2.7748.1292,2.2585.4522,4.3881,1.0335,6.5178,1.6133.7098,3.162,1.2257,4.6461,1.6133.9028.258,1.8071.3872,2.6453.3872,1.6133.1288,3.162,0,4.7753-.3872,2.453-.581,5.0337-1.6779,7.6151-2.9686,2.5814-1.2261,5.3559-2.7748,8.1957-4.0656,2.9036-1.2907,5.9372-2.3877,9.2285-2.3877s6.3886,1.0969,9.2923,2.3877c2.839,1.2907,5.5497,2.8394,8.1957,4.0656,2.5807,1.2907,5.0983,2.3877,7.6144,2.9686,1.6133.3872,3.2266.516,4.8399.3872.839-.0646,1.7425-.1938,2.5814-.3872,1.4841-.3876,3.0336-.9035,4.6469-1.6133.5152-2.1297.9028-4.2593,1.0319-6.5178.0646-.9035.1292-1.8717.1292-2.7748C76.5997,17.1654,59.4339,0,38.268,0Z" fill="currentColor"/><path d="M72.8563,54.7153c-1.1611,2.5169-2.5807,4.8399-4.3232,6.9696-1.7425.1934-3.4204.1288-5.1629-.2584-2.5161-.6452-5.0337-1.6779-7.6144-2.9682-2.646-1.2907-5.3567-2.7748-8.1957-4.0656-2.9036-1.2907-6.0011-2.3877-9.2923-2.3877s-6.3248,1.0969-9.2285,2.3877c-2.8398,1.2907-5.6143,2.7748-8.1957,4.0656-2.5814,1.2903-5.1621,2.3231-7.6151,2.9682-1.7425.3872-3.4204.4518-5.1621.2584-1.7425-2.1297-3.2266-4.4527-4.3885-6.9696.7105.1934,1.4195.3872,2.1301.5806,2.4515.581,4.9045.581,7.4206,0,2.453-.5806,5.0337-1.6133,7.6151-2.9036,2.5814-1.2907,5.3559-2.8394,8.1957-4.0656,2.9036-1.2907,5.9372-2.3877,9.2285-2.3877s6.3886,1.0969,9.2923,2.3877c2.839,1.2261,5.5497,2.7748,8.1957,4.0656,2.5807,1.2903,5.0983,2.3231,7.6144,2.9036,2.4523.581,4.9045.581,7.4214,0,.6452-.1288,1.3557-.3226,2.0647-.5806Z" fill="currentColor"/><path d="M63.1119,67.428c-1.7425,1.5491-3.678,2.904-5.7427,4.001-.5168-.258-1.0973-.516-1.6133-.7744-2.646-1.2903-5.3567-2.7748-8.1957-4.0656-2.9036-1.2903-6.0011-2.3877-9.2923-2.3877s-6.3248,1.0973-9.2285,2.3877c-2.8398,1.2907-5.6143,2.7752-8.1957,4.0656-.516.2584-1.0973.5164-1.6133.7744-2.0647-1.0969-4.001-2.4519-5.7435-4.001,2.3877-.5806,4.8399-1.6775,7.3568-2.8394,2.5814-1.2903,5.3559-2.8394,8.1957-4.1298,2.9036-1.2907,5.9372-2.3877,9.2285-2.3877s6.3886,1.0969,9.2923,2.3877c2.839,1.2903,5.5497,2.8394,8.1957,4.1298,2.5161,1.1619,4.9045,2.2589,7.356,2.8394Z" fill="currentColor"/></g></g></svg>