@almadar/shell-web 0.0.0-stage → 1.0.0

package/dist/parseLessonSegments-GpCeMrb2.d.ts

@@ -0,0 +1,334 @@
+import { OrbitalSchema, A11yProps, EventEmit } from '@almadar/core';
+import React__default from 'react';
+
+type AnnotationKind = 'question' | 'note';
+interface ContentAnnotation {
+    /** Unique id, echoed in the click event payload */
+    id: string;
+    /** Exact passage to highlight (first occurrence in the rendered text) */
+    text: string;
+    /** Highlight colour: `question` or `note` */
+    kind: AnnotationKind;
+}
+
+/**
+ * Pure vim-flavored editor motion module. No DOM — `CodeBlock.tsx` drives a
+ * real `<textarea>` selection through this (Almadar Studio V4 §14 plan, P1
+ * E2); this module only computes offsets and text.
+ *
+ * Caret convention: an integer offset in `[0, text.length]`, a gap position
+ * (matches `textarea.selectionStart`) — except `word-end`, `line-end` and
+ * `match-bracket`, which land ON the index of their target character (vim's
+ * `e`/`$`/`%` block-cursor convention), so `motionRange` widens those by one
+ * to make an operator's range inclusive of that char.
+ *
+ * `EDITOR_MOTIONS` / `EDITOR_OPERATORS` are the single source of truth for
+ * the closed vocabularies — `CodeBlock.tsx`'s `motions`/`operators` prop
+ * defaults must list the same members (kept as JSON literals there for the
+ * pattern-registry parser; `test/CodeBlock.editable.test.tsx` asserts they
+ * stay in sync).
+ */
+declare const EDITOR_MOTIONS: readonly ["left", "right", "up", "down", "word-forward", "word-back", "word-end", "line-start", "line-end", "first-nonblank", "doc-start", "doc-end", "paragraph-forward", "paragraph-back", "line", "selection", "match-bracket"];
+type EditorMotion = (typeof EDITOR_MOTIONS)[number];
+declare const EDITOR_OPERATORS: readonly ["delete", "yank", "change", "put", "put-before", "undo", "redo", "join", "toggle-case", "indent", "dedent", "replace"];
+type EditorOperator = (typeof EDITOR_OPERATORS)[number];
+declare function isEditorMotion(value: string): value is EditorMotion;
+declare function isEditorOperator(value: string): value is EditorOperator;
+/** Fixed indent unit for the `indent`/`dedent` operators (two spaces). */
+declare const INDENT_UNIT = "  ";
+/** New caret offset after applying `motion` `count` times. `line`/`selection` are range-only — caret is unchanged. */
+declare function applyMotion(text: string, caret: number, motion: EditorMotion, count: number): number;
+/** The `[start, end)` range an operator acts on for `motion`. */
+declare function motionRange(text: string, caret: number, motion: EditorMotion, count: number, selection?: [number, number]): [number, number];
+interface ApplyOperatorInput {
+    text: string;
+    /** `textarea.selectionStart` at the time the operator fired — the anchor for caret-based operators (put/put-before/join) that don't act over `range`. */
+    caret: number;
+    /** The `[start, end)` range from `motionRange` — the anchor for range-based operators (delete/yank/change/toggle-case/indent/dedent/replace). */
+    range: [number, number];
+    operator: EditorOperator;
+    /** The motion paired with this operator. `change` special-cases `line`; delete/yank/change use it to set the returned `registerLinewise`. */
+    motion: EditorMotion;
+    count: number;
+    register: string;
+    registerLinewise: boolean;
+}
+interface ApplyOperatorResult {
+    text: string;
+    caret: number;
+    register: string;
+    registerLinewise: boolean;
+}
+/** Apply `operator`. `undo`/`redo` never reach here — they're history-stack operations handled by `useEditorCapabilities`. */
+declare function applyOperator(input: ApplyOperatorInput): ApplyOperatorResult;
+
+/**
+ * Content Segment Parsing Utilities
+ *
+ * Parses rich content with code blocks and quiz tags into structured
+ * segments for rendering. Detects orbital schemas in JSON code blocks
+ * and marks them for JazariStateMachine rendering.
+ */
+
+/** Segment types for content rendering */
+type ContentSegment = {
+    type: 'markdown';
+    content: string;
+} | {
+    type: 'code';
+    language: string;
+    content: string;
+} | {
+    type: 'orbital';
+    language: string;
+    content: string;
+    schema: OrbitalSchema;
+} | {
+    type: 'quiz';
+    question: string;
+    answer: string;
+};
+/**
+ * Parse markdown content to extract code blocks.
+ *
+ * Splits markdown into segments of plain markdown and fenced code blocks.
+ * JSON/orb code blocks containing orbital schemas are tagged as 'orbital'.
+ */
+declare function parseMarkdownWithCodeBlocks(content: string | undefined | null): ContentSegment[];
+/**
+ * Parse content to extract all segments including quiz tags and code blocks.
+ *
+ * Supported tags:
+ * - <question>q</question><answer>a</answer> — Quiz Q&A
+ *
+ * Also handles fenced code blocks (```language...```) with orbital detection.
+ */
+declare function parseContentSegments(content: string | undefined | null): ContentSegment[];
+
+/**
+ * BloomQuizBlock Molecule Component
+ *
+ * Practice Q&A with Bloom's Taxonomy level badge. Emits `UI:ANSWER_BLOOM { index, level }`.
+ *
+ * Event Contract:
+ * - Emits: UI:ANSWER_BLOOM { index, level }
+ * - entityAware: false
+ */
+
+type BloomLevel = 'remember' | 'understand' | 'apply' | 'analyze' | 'evaluate' | 'create';
+interface BloomQuizBlockProps extends A11yProps {
+    level: BloomLevel;
+    question: string;
+    answer: string;
+    /** Zero-based index (used in the emitted event payload) */
+    index?: number;
+    /** Whether the learner has already answered */
+    isAnswered?: boolean;
+    /** Event name emitted on first reveal (as `UI:<answerEvent>`). Defaults to 'ANSWER_BLOOM'. */
+    answerEvent?: string;
+    /** Additional CSS classes */
+    className?: string;
+}
+declare const BloomQuizBlock: React__default.FC<BloomQuizBlockProps>;
+
+/**
+ * CodeRunnerPanel Organism Component
+ *
+ * Editable code block with Run/Reset buttons and a terminal output pane.
+ * Running is the program's job: Run emits the declared `runEvent` request and the
+ * program binds the result back through `output` / `running` / `error`.
+ *
+ * Event Contract:
+ * - Emits: UI:<runEvent> { code, language, runId? } on Run
+ * - Emits: UI:<resetEvent> { runId? } on Reset (when declared)
+ * - Emits: UI:COPY_CODE { language, success } on Copy
+ * - entityAware: false
+ */
+
+interface CodeSimulationOutput {
+    stdout: string;
+    stderr: string;
+    exitCode: number;
+    testResults: Array<{
+        input: string;
+        expectedOutput: string;
+        actualOutput: string;
+        passed: boolean;
+    }>;
+}
+interface CodeRunnerPanelProps extends Omit<React__default.AriaAttributes, keyof A11yProps>, A11yProps {
+    /** Initial code content */
+    code: string;
+    /** Programming language for syntax highlighting */
+    language: string;
+    /** Whether the panel is editable and runnable (default false = read-only code block) */
+    runnable?: boolean;
+    /** Event emitted on Run as `UI:<runEvent>` with `{ code, language, runId }`. Defaults to 'RUN_CODE'. */
+    runEvent?: EventEmit<{
+        code: string;
+        language: string;
+        runId: string;
+    }>;
+    /** Event emitted on Reset as `UI:<resetEvent>` with `{ runId }`; Reset only restores the code when absent. */
+    resetEvent?: EventEmit<{
+        runId: string;
+    }>;
+    /** Identifies this panel in its run/reset payloads (e.g. a lesson segment); empty when one panel stands alone. */
+    runId?: string;
+    /** The program's result for the last run, bound back into the panel. */
+    output?: CodeSimulationOutput | null;
+    /** True while the program is running the code. */
+    running?: boolean;
+    /** A run failure message from the program; replaces the output body. */
+    error?: string | null;
+    /** Additional CSS classes */
+    className?: string;
+}
+declare const CodeRunnerPanel: React__default.FC<CodeRunnerPanelProps>;
+
+/**
+ * SegmentRenderer Organism Component
+ *
+ * Renders a parsed array of LessonSegments — markdown, code, quizzes,
+ * activation prompts, connections, reflections, Bloom questions.
+ * The `visualization` segment type is passed through as a no-op unless the
+ * caller provides `onRenderVisualization` (future extensibility hook).
+ *
+ * Event Contract:
+ * - Delegates to child molecules: UI:{activationSaveEvent|SAVE_ACTIVATION}, UI:{reflectionSaveEvent|SAVE_REFLECTION}, UI:{bloomAnswerEvent|ANSWER_BLOOM}
+ * - Emits (selection / highlights): UI:{askEvent} { selectedText }, UI:{noteEvent} { selectedText }, UI:{annotationEvent} { annotationId }
+ * - entityAware: false
+ */
+
+type InteractiveOrbitalType = 'algorithms' | 'math' | 'physics' | 'biology' | 'chemistry' | 'probability';
+type LessonSegment = {
+    type: 'markdown';
+    content: string;
+} | {
+    type: 'code';
+    language: string;
+    content: string;
+    runnable?: boolean;
+} | {
+    type: 'quiz';
+    question: string;
+    answer: string;
+} | {
+    type: 'activate';
+    question: string;
+} | {
+    type: 'connect';
+    content: string;
+} | {
+    type: 'reflect';
+    prompt: string;
+} | {
+    type: 'bloom';
+    level: BloomLevel;
+    question: string;
+    answer: string;
+} | {
+    type: 'visualization';
+    visualizationType: InteractiveOrbitalType;
+    description: string;
+};
+/**
+ * User progress state passed into SegmentRenderer. Declared here (rather than
+ * alongside `LessonSegment` in `lib/parseLessonSegments.ts`) so the
+ * pattern-sync scanner — which only indexes types under `components/**` —
+ * can resolve it to a concrete `.lolo` object shape instead of `json`.
+ */
+interface LessonUserProgress {
+    activationResponse?: string;
+    reflectionNotes?: string[];
+    bloomAnswered?: Record<number, boolean>;
+}
+interface SegmentRendererProps extends Omit<React__default.AriaAttributes, keyof A11yProps>, A11yProps {
+    /** Parsed lesson segments (see `parseLessonSegments`). Ignored when `lesson` is given. */
+    segments?: LessonSegment[];
+    /** Raw lesson markdown with learning tags; parsed with `parseLessonSegments` and rendered */
+    lesson?: string;
+    /** Event emitted when the activation prompt is saved or skipped (as `UI:<activationSaveEvent>`) */
+    activationSaveEvent?: EventEmit<{
+        response: string;
+    }>;
+    /** Event emitted when a reflection note is saved (as `UI:<reflectionSaveEvent>`) */
+    reflectionSaveEvent?: EventEmit<{
+        index: number;
+        note: string;
+    }>;
+    /** Event emitted on the first reveal of a Bloom question (as `UI:<bloomAnswerEvent>`) */
+    bloomAnswerEvent?: EventEmit<{
+        index: number;
+        level: BloomLevel;
+    }>;
+    /** Event emitted when the reader picks Ask on selected text (as `UI:<askEvent>`) */
+    askEvent?: EventEmit<{
+        selectedText: string;
+    }>;
+    /** Event emitted when the reader picks Note on selected text (as `UI:<noteEvent>`) */
+    noteEvent?: EventEmit<{
+        selectedText: string;
+    }>;
+    /** Ask action label (default: translated) */
+    askLabel?: string;
+    /** Note action label (default: translated) */
+    noteLabel?: string;
+    /**
+     * Passages to highlight. Each `text` is matched exactly against the markdown
+     * segments, first segment whose source contains it, first occurrence inside one
+     * rendered text node (outside code); one that spans formatting is not highlighted.
+     */
+    annotations?: ContentAnnotation[];
+    /** Event emitted when a highlighted passage is clicked (as `UI:<annotationEvent>`) */
+    annotationEvent?: EventEmit<{
+        annotationId?: string;
+    }>;
+    /** Additional CSS classes for the root container */
+    className?: string;
+    /** CSS classes for the outer wrapping div */
+    containerClassName?: string;
+    /** User progress for restoring activation/reflection state */
+    userProgress?: LessonUserProgress;
+    /**
+     * Event a runnable code block emits on Run (`{ code, language, runId }`, runId = the segment
+     * index). Omit to render runnable blocks read-only.
+     */
+    runCodeEvent?: EventEmit<{
+        code: string;
+        language: string;
+        runId: string;
+    }>;
+    /** Event a runnable code block emits on Reset (`{ runId }`). */
+    resetCodeEvent?: EventEmit<{
+        runId: string;
+    }>;
+    /** The program's run results, keyed by segment runId. */
+    codeOutputs?: Record<string, CodeSimulationOutput>;
+    /** The runId the program is currently running. */
+    runningCode?: string;
+    /**
+     * Optional render slot for `visualization` segment types. When not provided,
+     * visualization segments are silently skipped. Callers can wire this to any
+     * custom component or orbital generator.
+     */
+    onRenderVisualization?: (type: InteractiveOrbitalType, description: string, index: number) => React__default.ReactNode;
+}
+declare const SegmentRenderer: React__default.FC<SegmentRendererProps>;
+
+/**
+ * parseLessonSegments — parses lesson markdown with embedded learning-science
+ * XML-style tags into a typed Segment array.
+ *
+ * Supported tags: <activate>, <connect>, <reflect>, <bloom level="...">,
+ * <question>/<answer>, <visualize type="..." description="..." />.
+ *
+ * Tags may be open (unclosed) — the parser falls back to consuming content
+ * until the next recognised tag, a section heading (`\n\n#`), or end-of-input.
+ */
+
+/** Parse a lesson string into typed segments. Returns `[]` when input is empty. */
+declare function parseLessonSegments(lesson: string | undefined): LessonSegment[];
+
+export { EDITOR_MOTIONS as E, INDENT_UNIT as I, SegmentRenderer as S, EDITOR_OPERATORS as b, applyMotion as e, applyOperator as f, isEditorOperator as g, parseLessonSegments as h, isEditorMotion as i, parseMarkdownWithCodeBlocks as j, BloomQuizBlock as l, motionRange as m, CodeRunnerPanel as o, parseContentSegments as p };
+export type { ApplyOperatorInput as A, BloomLevel as B, ContentSegment as C, LessonSegment as L, ApplyOperatorResult as a, EditorMotion as c, EditorOperator as d, ContentAnnotation as k, BloomQuizBlockProps as n, CodeRunnerPanelProps as q, CodeSimulationOutput as r, LessonUserProgress as s, SegmentRendererProps as t };

package/dist/perf-CKiBKbkw.d.ts

@@ -0,0 +1,22 @@
+import { ProfilerOnRenderCallback } from 'react';
+import { P as PerfEntry } from './perf-Dr28-AgT.js';
+import './verification-C5pTeMJv.js';
+
+/**
+ * @almadar/ui/runtime — perf instrumentation
+ *
+ * React-specific consumption layer on top of the renderer-agnostic perf ring
+ * now living in `@almadar/runtime/ui/perf`. Re-exports the framework-free
+ * timing primitives and adds `useSyncExternalStore` / `React.Profiler` hooks.
+ */
+
+/**
+ * React hook: returns the current perf ring snapshot, re-renders on push.
+ */
+declare function usePerfBuffer(): readonly PerfEntry[];
+/**
+ * React.Profiler `onRender` callback. Records `actualDuration` per commit.
+ */
+declare const profilerOnRender: ProfilerOnRenderCallback;
+
+export { profilerOnRender as p, usePerfBuffer as u };

package/dist/perf-Dr28-AgT.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Renderer-agnostic perf instrumentation.
+ *
+ * Contains the timing ring + mark/measure primitives used by runtime-side
+ * schema prep and other framework-free work. React-specific consumption hooks
+ * stay in `@almadar/ui/lib/perf` and read this shared ring.
+ *
+ * Gated behind `createLogger('almadar:perf:canvas')` so production builds
+ * (LOG_LEVEL >= WARN) skip the work.
+ *
+ * @packageDocumentation
+ */
+declare const PERF_NAMESPACE = "almadar:perf:canvas";
+/**
+ * Perf metadata values are local instrumentation scalars. There is no
+ * corresponding @almadar/core concept, so this local fallback type replaces
+ * the previous Record<string, unknown> while keeping the surface concrete.
+ */
+type PerfDetailValue = string | number | boolean | null | undefined;
+interface PerfDetail {
+    readonly [key: string]: PerfDetailValue;
+}
+interface PerfEntry {
+    readonly name: string;
+    readonly durationMs: number;
+    readonly ts: number;
+    readonly detail?: Readonly<PerfDetail>;
+}
+/**
+ * Start a phase. Returns an opaque token; pass to {@link perfEnd}.
+ * Returns -1 when the namespace is gated off.
+ */
+declare function perfStart(name: string): number;
+declare function perfEnd(name: string, startToken: number, detail?: PerfDetail): void;
+/** Synchronous wrapper that times a fn end-to-end. */
+declare function perfTime<T>(name: string, fn: () => T, detail?: PerfDetail): T;
+/** Async wrapper — the tick/effect paths are async end-to-end. */
+declare function perfTimeAsync<T>(name: string, fn: () => Promise<T> | T): Promise<T>;
+/** Record a non-duration scalar (queue depth, entries/pass) into the summary. */
+declare function perfGauge(name: string, value: number): void;
+declare function getSnapshot(): readonly PerfEntry[];
+declare function subscribe(fn: () => void): () => void;
+/** Push a pre-computed entry (e.g. React.Profiler callback). */
+declare function pushPerfEntry(entry: PerfEntry): void;
+/** Clear the ring and notify subscribers. */
+declare function clearPerf(): void;
+/**
+ * Primitives a renderer-specific hook (e.g. React's `useSyncExternalStore`)
+ * uses to consume the perf ring.
+ */
+declare const perfStore: {
+    subscribe: typeof subscribe;
+    getSnapshot: typeof getSnapshot;
+};
+
+export { PERF_NAMESPACE as a, perfStart as b, clearPerf as c, perfTime as d, perfGauge as g, perfStore as h, perfTimeAsync as i, pushPerfEntry as j, perfEnd as p };
+export type { PerfEntry as P, PerfDetail as e, PerfDetailValue as f };

package/dist/prism-X5YWKXO5.js

@@ -0,0 +1,136 @@
+import './chunk-G7DCAZ22.js';
+import SyntaxHighlighter from 'react-syntax-highlighter/dist/esm/prism-light.js';
+import createHighlightElement from 'react-syntax-highlighter/dist/esm/create-element.js';
+import dark from 'react-syntax-highlighter/dist/esm/styles/prism/vsc-dark-plus.js';
+import light from 'react-syntax-highlighter/dist/esm/styles/prism/vs.js';
+import { orbLanguage, loloLanguage } from '@almadar/syntax';
+import langJson from 'react-syntax-highlighter/dist/esm/languages/prism/json.js';
+import langJavascript from 'react-syntax-highlighter/dist/esm/languages/prism/javascript.js';
+import langTypescript from 'react-syntax-highlighter/dist/esm/languages/prism/typescript.js';
+import langJsx from 'react-syntax-highlighter/dist/esm/languages/prism/jsx.js';
+import langTsx from 'react-syntax-highlighter/dist/esm/languages/prism/tsx.js';
+import langCss from 'react-syntax-highlighter/dist/esm/languages/prism/css.js';
+import langMarkdown from 'react-syntax-highlighter/dist/esm/languages/prism/markdown.js';
+import langBash from 'react-syntax-highlighter/dist/esm/languages/prism/bash.js';
+import langYaml from 'react-syntax-highlighter/dist/esm/languages/prism/yaml.js';
+import langRust from 'react-syntax-highlighter/dist/esm/languages/prism/rust.js';
+import langPython from 'react-syntax-highlighter/dist/esm/languages/prism/python.js';
+import langSql from 'react-syntax-highlighter/dist/esm/languages/prism/sql.js';
+import langDiff from 'react-syntax-highlighter/dist/esm/languages/prism/diff.js';
+import langToml from 'react-syntax-highlighter/dist/esm/languages/prism/toml.js';
+import langGo from 'react-syntax-highlighter/dist/esm/languages/prism/go.js';
+import langGraphql from 'react-syntax-highlighter/dist/esm/languages/prism/graphql.js';
+import langClojure from 'react-syntax-highlighter/dist/esm/languages/prism/clojure.js';
+import langHaskell from 'react-syntax-highlighter/dist/esm/languages/prism/haskell.js';
+import langLisp from 'react-syntax-highlighter/dist/esm/languages/prism/lisp.js';
+import langScheme from 'react-syntax-highlighter/dist/esm/languages/prism/scheme.js';
+import langScala from 'react-syntax-highlighter/dist/esm/languages/prism/scala.js';
+import langElixir from 'react-syntax-highlighter/dist/esm/languages/prism/elixir.js';
+import langErlang from 'react-syntax-highlighter/dist/esm/languages/prism/erlang.js';
+import langElm from 'react-syntax-highlighter/dist/esm/languages/prism/elm.js';
+import langFsharp from 'react-syntax-highlighter/dist/esm/languages/prism/fsharp.js';
+import langOcaml from 'react-syntax-highlighter/dist/esm/languages/prism/ocaml.js';
+import langJava from 'react-syntax-highlighter/dist/esm/languages/prism/java.js';
+import langC from 'react-syntax-highlighter/dist/esm/languages/prism/c.js';
+import langCpp from 'react-syntax-highlighter/dist/esm/languages/prism/cpp.js';
+import langCsharp from 'react-syntax-highlighter/dist/esm/languages/prism/csharp.js';
+import langObjectivec from 'react-syntax-highlighter/dist/esm/languages/prism/objectivec.js';
+import langPhp from 'react-syntax-highlighter/dist/esm/languages/prism/php.js';
+import langRuby from 'react-syntax-highlighter/dist/esm/languages/prism/ruby.js';
+import langSwift from 'react-syntax-highlighter/dist/esm/languages/prism/swift.js';
+import langKotlin from 'react-syntax-highlighter/dist/esm/languages/prism/kotlin.js';
+import langLua from 'react-syntax-highlighter/dist/esm/languages/prism/lua.js';
+import langR from 'react-syntax-highlighter/dist/esm/languages/prism/r.js';
+import langDart from 'react-syntax-highlighter/dist/esm/languages/prism/dart.js';
+import langJulia from 'react-syntax-highlighter/dist/esm/languages/prism/julia.js';
+import langFortran from 'react-syntax-highlighter/dist/esm/languages/prism/fortran.js';
+import langPerl from 'react-syntax-highlighter/dist/esm/languages/prism/perl.js';
+import langPowershell from 'react-syntax-highlighter/dist/esm/languages/prism/powershell.js';
+import langMakefile from 'react-syntax-highlighter/dist/esm/languages/prism/makefile.js';
+import langNginx from 'react-syntax-highlighter/dist/esm/languages/prism/nginx.js';
+import langIni from 'react-syntax-highlighter/dist/esm/languages/prism/ini.js';
+import langClike from 'react-syntax-highlighter/dist/esm/languages/prism/clike.js';
+
+SyntaxHighlighter.registerLanguage("json", langJson);
+SyntaxHighlighter.registerLanguage("javascript", langJavascript);
+SyntaxHighlighter.registerLanguage("js", langJavascript);
+SyntaxHighlighter.registerLanguage("typescript", langTypescript);
+SyntaxHighlighter.registerLanguage("ts", langTypescript);
+SyntaxHighlighter.registerLanguage("jsx", langJsx);
+SyntaxHighlighter.registerLanguage("tsx", langTsx);
+SyntaxHighlighter.registerLanguage("css", langCss);
+SyntaxHighlighter.registerLanguage("markdown", langMarkdown);
+SyntaxHighlighter.registerLanguage("md", langMarkdown);
+SyntaxHighlighter.registerLanguage("bash", langBash);
+SyntaxHighlighter.registerLanguage("shell", langBash);
+SyntaxHighlighter.registerLanguage("sh", langBash);
+SyntaxHighlighter.registerLanguage("yaml", langYaml);
+SyntaxHighlighter.registerLanguage("yml", langYaml);
+SyntaxHighlighter.registerLanguage("rust", langRust);
+SyntaxHighlighter.registerLanguage("python", langPython);
+SyntaxHighlighter.registerLanguage("py", langPython);
+SyntaxHighlighter.registerLanguage("sql", langSql);
+SyntaxHighlighter.registerLanguage("diff", langDiff);
+SyntaxHighlighter.registerLanguage("toml", langToml);
+SyntaxHighlighter.registerLanguage("go", langGo);
+SyntaxHighlighter.registerLanguage("graphql", langGraphql);
+SyntaxHighlighter.registerLanguage("clojure", langClojure);
+SyntaxHighlighter.registerLanguage("clj", langClojure);
+SyntaxHighlighter.registerLanguage("edn", langClojure);
+SyntaxHighlighter.registerLanguage("haskell", langHaskell);
+SyntaxHighlighter.registerLanguage("hs", langHaskell);
+SyntaxHighlighter.registerLanguage("lisp", langLisp);
+SyntaxHighlighter.registerLanguage("scheme", langScheme);
+SyntaxHighlighter.registerLanguage("scala", langScala);
+SyntaxHighlighter.registerLanguage("elixir", langElixir);
+SyntaxHighlighter.registerLanguage("ex", langElixir);
+SyntaxHighlighter.registerLanguage("exs", langElixir);
+SyntaxHighlighter.registerLanguage("erlang", langErlang);
+SyntaxHighlighter.registerLanguage("erl", langErlang);
+SyntaxHighlighter.registerLanguage("elm", langElm);
+SyntaxHighlighter.registerLanguage("fsharp", langFsharp);
+SyntaxHighlighter.registerLanguage("fs", langFsharp);
+SyntaxHighlighter.registerLanguage("fsx", langFsharp);
+SyntaxHighlighter.registerLanguage("ocaml", langOcaml);
+SyntaxHighlighter.registerLanguage("ml", langOcaml);
+SyntaxHighlighter.registerLanguage("java", langJava);
+SyntaxHighlighter.registerLanguage("c", langC);
+SyntaxHighlighter.registerLanguage("cpp", langCpp);
+SyntaxHighlighter.registerLanguage("c++", langCpp);
+SyntaxHighlighter.registerLanguage("cc", langCpp);
+SyntaxHighlighter.registerLanguage("cxx", langCpp);
+SyntaxHighlighter.registerLanguage("hpp", langCpp);
+SyntaxHighlighter.registerLanguage("h", langCpp);
+SyntaxHighlighter.registerLanguage("csharp", langCsharp);
+SyntaxHighlighter.registerLanguage("cs", langCsharp);
+SyntaxHighlighter.registerLanguage("objectivec", langObjectivec);
+SyntaxHighlighter.registerLanguage("objc", langObjectivec);
+SyntaxHighlighter.registerLanguage("php", langPhp);
+SyntaxHighlighter.registerLanguage("ruby", langRuby);
+SyntaxHighlighter.registerLanguage("rb", langRuby);
+SyntaxHighlighter.registerLanguage("swift", langSwift);
+SyntaxHighlighter.registerLanguage("kotlin", langKotlin);
+SyntaxHighlighter.registerLanguage("kt", langKotlin);
+SyntaxHighlighter.registerLanguage("lua", langLua);
+SyntaxHighlighter.registerLanguage("r", langR);
+SyntaxHighlighter.registerLanguage("dart", langDart);
+SyntaxHighlighter.registerLanguage("julia", langJulia);
+SyntaxHighlighter.registerLanguage("fortran", langFortran);
+SyntaxHighlighter.registerLanguage("f90", langFortran);
+SyntaxHighlighter.registerLanguage("f95", langFortran);
+SyntaxHighlighter.registerLanguage("perl", langPerl);
+SyntaxHighlighter.registerLanguage("pl", langPerl);
+SyntaxHighlighter.registerLanguage("powershell", langPowershell);
+SyntaxHighlighter.registerLanguage("ps1", langPowershell);
+SyntaxHighlighter.registerLanguage("makefile", langMakefile);
+SyntaxHighlighter.registerLanguage("make", langMakefile);
+SyntaxHighlighter.registerLanguage("nginx", langNginx);
+SyntaxHighlighter.registerLanguage("ini", langIni);
+SyntaxHighlighter.registerLanguage("clike", langClike);
+function registerProgramLanguages() {
+  SyntaxHighlighter.registerLanguage("orb", orbLanguage);
+  SyntaxHighlighter.registerLanguage("lolo", loloLanguage);
+}
+var prism = { SyntaxHighlighter, createHighlightElement, dark, light, clike: langClike };
+
+export { prism, registerProgramLanguages };