@revenexx/editor 0.1.0

package/dist/modules/iframes/runtime/features/iframes/Editor/index.vue

@@ -0,0 +1,222 @@
+<template>
+  <div class="_bk_flex _bk_h-full" @wheel.capture.stop>
+    <!-- Preview area -->
+    <div class="_bk_flex-1 _bk_min-w-0">
+      <div
+        v-if="iframeSrc"
+        class="_bk_overflow-auto _bk_bg-mono-50 _bk_rounded _bk_p-20 _bk_h-full"
+      >
+        <div class="_bk_relative _bk_mx-auto" :style="{ width: containerWidth + 'px' }">
+          <div class="_bk_border _bk_border-mono-200 _bk_overflow-hidden">
+            <iframe
+              :src="iframeSrc"
+              class="_bk_overflow-hidden"
+              scrolling="no"
+              :style="{
+  width: '100%',
+  height: resolved.height + 'px',
+  border: 'none',
+  display: 'block',
+  pointerEvents: isDragging ? 'none' : 'auto'
+}"
+            />
+          </div>
+
+          <!-- Bottom resize handle -->
+          <div
+            class="_bk_flex _bk_items-center _bk_justify-center _bk_cursor-ns-resize _bk_bg-mono-200 _bk_hover:bg-accent-300"
+            style="height: 8px"
+            @pointerdown.prevent="onPointerDown('height', $event)"
+          />
+
+          <!-- Right resize handle -->
+          <div
+            class="_bk_absolute _bk_top-0 _bk_cursor-ew-resize _bk_bg-mono-200 _bk_hover:bg-accent-300"
+            :style="{
+  right: '-8px',
+  width: '8px',
+  height: '100%'
+}"
+            @pointerdown.prevent="onPointerDown('width', $event)"
+          />
+
+          <!-- Corner resize handle -->
+          <div
+            class="_bk_absolute _bk_cursor-nwse-resize _bk_bg-mono-300 _bk_hover:bg-accent-400"
+            :style="{
+  right: '-8px',
+  bottom: '0',
+  width: '8px',
+  height: '8px'
+}"
+            @pointerdown.prevent="onPointerDown('both', $event)"
+          />
+        </div>
+      </div>
+
+      <div v-else class="_bk_text-mono-500 _bk_p-20 _bk_text-center">
+        The block must be rendered on the page before iframe heights can be
+        configured.
+      </div>
+    </div>
+
+    <!-- Sidebar -->
+    <div
+      class="_bk_flex _bk_flex-col _bk_gap-15 _bk_border-l _bk_border-mono-200 _bk_p-15"
+      style="width: 200px; flex-shrink: 0"
+    >
+      <!-- Current dimensions -->
+      <div class="_bk_text-mono-500 _bk_font-mono _bk_text-center" style="font-size: 11px">
+        {{ containerWidth }}px &times; {{ resolved.height }}px
+      </div>
+
+      <!-- Viewport presets -->
+      <div class="_bk_flex _bk_flex-col _bk_gap-3">
+        <div
+          class="_bk_text-mono-500 _bk_font-mono"
+          style="
+            font-size: 10px;
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+          "
+        >
+          Presets
+        </div>
+        <button
+          v-for="(vp, key) in VIEWPORTS"
+          :key="key"
+          type="button"
+          class="bk-button bk-scheme-mono bk-is-light bk-is-small"
+          :class="{
+  'bk-scheme-accent bk-is-dark': containerWidth === vp.width
+}"
+          @click="containerWidth = vp.width"
+        >
+          {{ vp.label }} ({{ vp.width }}px)
+        </button>
+      </div>
+
+      <!-- Breakpoints list -->
+      <div v-if="sortedEntries.length" class="_bk_flex _bk_flex-col _bk_gap-3">
+        <div
+          class="_bk_text-mono-500 _bk_font-mono"
+          style="
+            font-size: 10px;
+            text-transform: uppercase;
+            letter-spacing: 0.05em;
+          "
+        >
+          Breakpoints
+        </div>
+        <div
+          v-for="entry in sortedEntries"
+          :key="entry.key"
+          class="_bk_flex _bk_items-center _bk_gap-5 _bk_rounded _bk_px-5 _bk_cursor-pointer"
+          :class="
+  entry.key === resolved.widthKey ? '_bk_bg-accent-100 _bk_text-accent-900' : '_bk_hover:bg-mono-100'
+"
+          style="height: 30px"
+          @click="containerWidth = entry.width"
+        >
+          <span class="_bk_font-mono _bk_flex-1" style="font-size: 12px">
+            {{ entry.width }}px &rarr; {{ entry.height }}px
+          </span>
+          <button
+            type="button"
+            class="_bk_text-mono-400 _bk_hover:text-red-normal"
+            style="font-size: 14px; line-height: 1"
+            @click.stop="deleteEntry(entry.key)"
+          >
+            &times;
+          </button>
+        </div>
+      </div>
+    </div>
+  </div>
+</template>
+
+<script setup>
+import { ref, computed, onBeforeUnmount, useBlokkli } from "#imports";
+import { VIEWPORTS } from "#blokkli-build/iframes-config";
+const props = defineProps({
+  data: { type: [Object, null], required: true },
+  uuid: { type: String, required: true },
+  optionKey: { type: String, required: true }
+});
+const DEFAULT_HEIGHT = 400;
+const { directive } = useBlokkli();
+const iframeSrc = computed(
+  () => directive.getValueElement(props.uuid, "iframe") || ""
+);
+const heights = ref(
+  props.data && Object.keys(props.data).length > 0 ? { ...props.data } : Object.values(VIEWPORTS).reduce((acc, vp) => {
+    acc[String(vp.width)] = DEFAULT_HEIGHT;
+    return acc;
+  }, {})
+);
+const firstViewport = Object.values(VIEWPORTS)[0];
+const containerWidth = ref(firstViewport?.width ?? 375);
+const sortedEntries = computed(
+  () => Object.entries(heights.value).map(([w, h]) => ({ width: Number(w), height: h, key: w })).filter((e) => !Number.isNaN(e.width)).sort((a, b) => a.width - b.width)
+);
+const resolved = computed(() => {
+  const sorted = sortedEntries.value;
+  if (!sorted.length) {
+    return { height: DEFAULT_HEIGHT, widthKey: "" };
+  }
+  const match = sorted.find((bp) => bp.width >= containerWidth.value);
+  if (match) {
+    return { height: match.height, widthKey: match.key };
+  }
+  const largest = sorted[sorted.length - 1];
+  return { height: largest.height, widthKey: largest.key };
+});
+function deleteEntry(key) {
+  const { [key]: _, ...rest } = heights.value;
+  heights.value = rest;
+}
+const isDragging = ref(false);
+let dragAxis = "height";
+let dragStartX = 0;
+let dragStartY = 0;
+let dragStartWidth = 0;
+let dragStartHeight = 0;
+function onPointerDown(axis, e) {
+  isDragging.value = true;
+  dragAxis = axis;
+  dragStartX = e.clientX;
+  dragStartY = e.clientY;
+  dragStartWidth = containerWidth.value;
+  dragStartHeight = resolved.value.height;
+  document.addEventListener("pointermove", onPointerMove);
+  document.addEventListener("pointerup", onPointerUp);
+}
+function onPointerMove(e) {
+  if (dragAxis === "width" || dragAxis === "both") {
+    const deltaX = e.clientX - dragStartX;
+    containerWidth.value = Math.max(
+      200,
+      Math.round(dragStartWidth + deltaX * 2)
+    );
+  }
+  if (dragAxis === "height" || dragAxis === "both") {
+    const deltaY = e.clientY - dragStartY;
+    const newHeight = Math.max(50, Math.round(dragStartHeight + deltaY));
+    const widthKey = String(containerWidth.value);
+    heights.value = { ...heights.value, [widthKey]: newHeight };
+  }
+}
+function onPointerUp() {
+  isDragging.value = false;
+  document.removeEventListener("pointermove", onPointerMove);
+  document.removeEventListener("pointerup", onPointerUp);
+}
+onBeforeUnmount(() => {
+  document.removeEventListener("pointermove", onPointerMove);
+  document.removeEventListener("pointerup", onPointerUp);
+});
+function getData() {
+  return heights.value;
+}
+defineExpose({ getData });
+</script>

package/dist/modules/iframes/runtime/features/iframes/Editor/index.vue.d.ts

@@ -0,0 +1,12 @@
+import type { IframeHeightMap } from '../../../types.js';
+type __VLS_Props = {
+    data: IframeHeightMap | null;
+    uuid: string;
+    optionKey: string;
+};
+declare function getData(): IframeHeightMap;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {
+    getData: typeof getData;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/modules/iframes/runtime/types.d.ts

@@ -0,0 +1,10 @@
+/**
+ * A map of container widths (as strings) to iframe heights in pixels.
+ *
+ * The keys correspond to `@container` query breakpoints. For example,
+ * `{ "375": 400, "768": 600, "1440": 800 }` means:
+ * - At container width ≤ 375px, the iframe is 400px tall
+ * - At container width ≤ 768px, the iframe is 600px tall
+ * - At container width > 768px (default), the iframe is 800px tall
+ */
+export type IframeHeightMap = Record<string, number>;

package/dist/modules/index.d.mts

@@ -0,0 +1,8 @@
+export { b as Blokkli, B as BlokkliModule, d as defineBlokkliModule } from '../shared/editor.D28NbXr3.mjs';
+import 'nuxt/schema';
+import 'consola';
+import '../../dist/global/types/definitions.js';
+import '../../dist/global/types/theme.js';
+import '../../dist/global/types/colorOptions.js';
+import '@nuxt/kit';
+import '../../dist/global/types/features.js';

package/dist/modules/index.mjs

@@ -0,0 +1,10 @@
+function defineBlokkliModule(init) {
+  return function(options) {
+    return {
+      options,
+      init
+    };
+  };
+}
+
+export { defineBlokkliModule };

package/dist/modules/readability/index.d.mts

@@ -0,0 +1,12 @@
+import { B as BlokkliModule } from '../../shared/editor.D28NbXr3.mjs';
+import 'nuxt/schema';
+import 'consola';
+import '../../../dist/global/types/definitions.js';
+import '../../../dist/global/types/theme.js';
+import '../../../dist/global/types/colorOptions.js';
+import '@nuxt/kit';
+import '../../../dist/global/types/features.js';
+
+declare const _default: (options?: object | undefined) => BlokkliModule<object>;
+
+export { _default as default };

package/dist/modules/readability/index.mjs

@@ -0,0 +1,17 @@
+import { createResolver } from '@nuxt/kit';
+import { defineBlokkliModule } from '../index.mjs';
+import { fileURLToPath } from 'node:url';
+
+const resolve = createResolver(
+  fileURLToPath(new URL("./", import.meta.url))
+).resolve;
+const index = defineBlokkliModule({
+  setup({ context }) {
+    context.registerAdapterExtension(
+      "@blokkli/readability",
+      resolve("./runtime/adapter-extension")
+    );
+  }
+});
+
+export { index as default };

package/dist/modules/readability/runtime/adapter-extension.d.ts

@@ -0,0 +1,2 @@
+declare const _default: any;
+export default _default;

package/dist/modules/readability/runtime/adapter-extension.js

@@ -0,0 +1,5 @@
+import { defineBlokkliAdapterExtension } from "#blokkli/editor/adapter";
+import { createBuiltinReadabilityAnalyzer } from "./analyzers/builtin.js";
+export default defineBlokkliAdapterExtension(() => ({
+  getReadabilityAnalyzer: () => createBuiltinReadabilityAnalyzer()
+}));

package/dist/modules/readability/runtime/analyzers/builtin.d.ts

@@ -0,0 +1,10 @@
+import type { ReadabilityAnalyzer } from '#blokkli/editor/features/analyze/readability/types';
+/**
+ * Create the built-in readability analyzer using language-specific algorithms:
+ * Flesch Reading Ease → CEFR (en), Wiener Sachtextformel (de), LIX (fr),
+ * Gulpease (it). English syllable counting uses the `syllable` npm package,
+ * loaded lazily on the first `analyze()` call. German syllable counting uses
+ * a local vowel-group heuristic. French and Italian formulas don't need
+ * syllables at all.
+ */
+export declare function createBuiltinReadabilityAnalyzer(): ReadabilityAnalyzer;

package/dist/modules/readability/runtime/analyzers/builtin.js

@@ -0,0 +1,340 @@
+function fleschReadingEase(sentences, syllablesPerWord, coefficients) {
+  return coefficients.base - coefficients.sentences * sentences - coefficients.syllablesPerWord * syllablesPerWord;
+}
+function gulpeaseIndex(sentences, chars, words) {
+  const BASE = 89;
+  const SENTENCES_COEF = 300;
+  const CHARS_COEF = 10;
+  return (SENTENCES_COEF * sentences - CHARS_COEF * chars) / words + BASE;
+}
+function lix(words, longWords, wordsPerSentence) {
+  if (words === 0) return 0;
+  return wordsPerSentence + longWords * 100 / words;
+}
+const WSTF_VARIANT_1 = {
+  ms: 0.1935,
+  sl: 0.1672,
+  iw: 0.1297,
+  es: -0.0327,
+  base: -0.875
+};
+function wienerSachtextformel(words, sentences, longWords, polysyllables, monosyllables) {
+  const { ms, sl, iw, es, base } = WSTF_VARIANT_1;
+  const msVal = 100 * polysyllables / words;
+  const slVal = words / sentences;
+  const iwVal = 100 * longWords / words;
+  const esVal = 100 * monosyllables / words;
+  return base + ms * msVal + sl * slVal + iw * iwVal + es * esVal;
+}
+const FRE_COEFFICIENTS = {
+  en: { base: 206.835, sentences: 1.015, syllablesPerWord: 84.6 },
+  de: { base: 180, sentences: 1, syllablesPerWord: 58.5 },
+  fr: { base: 207, sentences: 1.015, syllablesPerWord: 73.6 },
+  it: { base: 217, sentences: 1.3, syllablesPerWord: 0.6 }
+};
+function getWords(text) {
+  return text.replace(/[^\p{L}\p{N}\s']/gu, "").toLowerCase().split(/\s+/g).filter(Boolean);
+}
+function getSentences(text) {
+  return text.match(/[^.!?。！？\n\r]+[.!?。！？]*[\n\r]*/gu) || [];
+}
+function sentenceCount(text) {
+  const sentences = getSentences(text);
+  let ignored = 0;
+  for (const s of sentences) {
+    if (getWords(s).length <= 2) ignored += 1;
+  }
+  return Math.max(1, sentences.length - ignored);
+}
+function wordCount(text) {
+  return getWords(text).length;
+}
+function longWordCount(text, threshold = 6) {
+  return getWords(text).filter((w) => w.length > threshold).length;
+}
+function charCount(text) {
+  return text.replace(/\s+/g, "").length;
+}
+function avgSentenceLength(text) {
+  const sentences = sentenceCount(text);
+  return sentences ? wordCount(text) / sentences : 0;
+}
+function avgWordsPerSentence(text) {
+  return avgSentenceLength(text);
+}
+function avgSyllablesPerWord(text, ctx, interval) {
+  const words = getWords(text);
+  if (!words.length) return 0;
+  let syllables = 0;
+  for (const w of words) syllables += ctx.syllableCount(w);
+  return interval ? syllables * interval / words.length : syllables / words.length;
+}
+function polysyllableCount(text, ctx) {
+  let count = 0;
+  for (const w of getWords(text)) {
+    if (ctx.syllableCount(w) > 2) count += 1;
+  }
+  return count;
+}
+function monosyllableCount(text, ctx) {
+  let count = 0;
+  for (const w of getWords(text)) {
+    if (ctx.syllableCount(w) === 1) count += 1;
+  }
+  return count;
+}
+const DE_VOWELS = /[aeiouäöüy]/i;
+const DE_DIPHTHONGS = /^(?:au|ei|eu|äu|ai|ie)/i;
+function countSyllablesDe(word) {
+  const w = word.toLowerCase();
+  if (!w) return 0;
+  let count = 0;
+  let i = 0;
+  let inVowelGroup = false;
+  while (i < w.length) {
+    const two = w.substring(i, i + 2);
+    if (DE_DIPHTHONGS.test(two)) {
+      if (!inVowelGroup) count += 1;
+      inVowelGroup = true;
+      i += 2;
+      continue;
+    }
+    if (DE_VOWELS.test(w[i])) {
+      if (!inVowelGroup) count += 1;
+      inVowelGroup = true;
+    } else {
+      inVowelGroup = false;
+    }
+    i += 1;
+  }
+  return Math.max(1, count);
+}
+let englishSyllable = null;
+async function loadEnglishSyllable() {
+  if (!englishSyllable) {
+    const mod = await import("syllable");
+    englishSyllable = mod.syllable;
+  }
+  return englishSyllable;
+}
+function fleschToCefr(score) {
+  if (score >= 90) return "A1";
+  if (score >= 80) return "A2";
+  if (score >= 70) return "B1";
+  if (score >= 60) return "B2";
+  if (score >= 50) return "C1";
+  return "C2";
+}
+const SCORE_CONFIGS = {
+  en: {
+    label: "CEFR",
+    compute: (text, ctx) => fleschReadingEase(
+      avgSentenceLength(text),
+      avgSyllablesPerWord(text, ctx),
+      FRE_COEFFICIENTS.en
+    ),
+    direction: "higher_easier",
+    // Aligned to CEFR buckets: easy = A1–B2 (FRE ≥ 60), ok = C1 (50–60),
+    // hard = C2 (< 50). Keeps each CEFR level in exactly one analyze section.
+    bands: { easy: 60, ok: 50 },
+    impactThresholds: [40, 25, 10],
+    minWords: 15,
+    formatScore: fleschToCefr,
+    referenceTable: [
+      { range: "FRE 90\u2013100", label: "A1 \u2014 beginners" },
+      { range: "FRE 80\u201390", label: "A2 \u2014 elementary" },
+      { range: "FRE 70\u201380", label: "B1 \u2014 intermediate" },
+      { range: "FRE 60\u201370", label: "B2 \u2014 upper intermediate (target)" },
+      { range: "FRE 50\u201360", label: "C1 \u2014 advanced (could be simpler)" },
+      {
+        range: "FRE 0\u201350",
+        label: "C2 \u2014 mastery \u2014 this is what gets flagged"
+      }
+    ]
+  },
+  de: {
+    label: "WSTF",
+    compute: (text, ctx) => wienerSachtextformel(
+      wordCount(text),
+      sentenceCount(text),
+      longWordCount(text),
+      polysyllableCount(text, ctx),
+      monosyllableCount(text, ctx)
+    ),
+    direction: "higher_harder",
+    bands: { easy: 15, ok: 18 },
+    impactThresholds: [16, 20, 24],
+    minWords: 5,
+    referenceTable: [
+      { range: "Below 8", label: "Very easy (children's books)" },
+      { range: "8\u201315", label: "Easy (standard website content)" },
+      { range: "15\u201318", label: "Moderately difficult (could be simpler)" },
+      {
+        range: "Above 18",
+        label: "Difficult \u2014 this is what gets flagged"
+      },
+      { range: "Above 24", label: "Critical \u2014 must be simplified" }
+    ]
+  },
+  fr: {
+    label: "LIX",
+    compute: (text) => lix(wordCount(text), longWordCount(text), avgWordsPerSentence(text)),
+    direction: "higher_harder",
+    bands: { easy: 40, ok: 59 },
+    impactThresholds: [50, 60, 70],
+    minWords: 5,
+    referenceTable: [
+      { range: "Below 25", label: "Very easy (children's books)" },
+      { range: "25\u201340", label: "Easy (simple articles)" },
+      { range: "40\u201350", label: "Medium (newspapers)" },
+      { range: "50\u201360", label: "Difficult (official documents)" },
+      {
+        range: "Above 60",
+        label: "Very difficult \u2014 this is what gets flagged"
+      },
+      { range: "Above 70", label: "Critical \u2014 must be simplified" }
+    ]
+  },
+  it: {
+    label: "Gulpease",
+    compute: (text) => gulpeaseIndex(sentenceCount(text), charCount(text), wordCount(text)),
+    direction: "higher_easier",
+    bands: { easy: 80, ok: 60 },
+    impactThresholds: [60, 50, 40],
+    minWords: 5,
+    referenceTable: [
+      { range: "Above 80", label: "Very easy (children's books)" },
+      { range: "60\u201380", label: "Easy (simple articles)" },
+      { range: "50\u201360", label: "Medium (newspapers)" },
+      { range: "40\u201350", label: "Difficult (official documents)" },
+      {
+        range: "Below 40",
+        label: "Very difficult \u2014 this is what gets flagged"
+      },
+      { range: "Below 30", label: "Critical \u2014 must be simplified" }
+    ]
+  }
+};
+const SUPPORTED_LANGUAGES = ["en", "de", "fr", "it"];
+function getConfig(langcode) {
+  if (isSupportedLangcode(langcode)) {
+    return SCORE_CONFIGS[langcode];
+  }
+  return SCORE_CONFIGS.en;
+}
+function isSupportedLangcode(v) {
+  return v === "en" || v === "de" || v === "fr" || v === "it";
+}
+function segmentWords(text) {
+  if ("Segmenter" in Intl) {
+    const seg = new Intl.Segmenter(void 0, { granularity: "word" });
+    const out = [];
+    for (const s of seg.segment(text)) {
+      if (s.isWordLike)
+        out.push(text.slice(s.index, s.index + s.segment.length));
+    }
+    return out;
+  }
+  return text.match(/\p{Letter}+(?:'\p{Letter}+)?/gu) ?? [];
+}
+function safe(fn) {
+  try {
+    const n = fn();
+    return Number.isFinite(n) ? n : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function round(n) {
+  return Math.round(n * 10) / 10;
+}
+function classifyBandGeneric(score, config) {
+  if (config.direction === "higher_easier") {
+    if (score >= config.bands.easy) return "easy";
+    if (score >= config.bands.ok) return "ok";
+    return "hard";
+  }
+  if (score <= config.bands.easy) return "easy";
+  if (score <= config.bands.ok) return "ok";
+  return "hard";
+}
+function impactForScoreGeneric(score, config) {
+  const [moderate, serious, critical] = config.impactThresholds;
+  if (config.direction === "higher_easier") {
+    if (score < critical) return "critical";
+    if (score < serious) return "serious";
+    if (score < moderate) return "moderate";
+    return "minor";
+  }
+  if (score >= critical) return "critical";
+  if (score >= serious) return "serious";
+  if (score >= moderate) return "moderate";
+  return "minor";
+}
+function buildAgentContext(config) {
+  const rows = config.referenceTable.map((row) => `- ${row.range}: ${row.label}`).join("\n");
+  return `## ${config.label} Score Reference
+
+${rows}`;
+}
+export function createBuiltinReadabilityAnalyzer() {
+  return {
+    id: "builtin",
+    label: (langcode) => {
+      if (langcode === "de") return "Lesbarkeit";
+      return "Readability";
+    },
+    description: "Analyzes text readability using language-specific algorithms (LIX, Wiener Sachtextformel, Gulpease).",
+    supportedLanguages: SUPPORTED_LANGUAGES,
+    minWordsForConfidence(langcode) {
+      return getConfig(langcode).minWords;
+    },
+    scoreLabel(langcode) {
+      return getConfig(langcode).label;
+    },
+    async analyze(texts, langcode) {
+      if (!isSupportedLangcode(langcode)) {
+        return texts.map(() => null);
+      }
+      const syllableCount = langcode === "en" ? await loadEnglishSyllable() : countSyllablesDe;
+      const ctx = { syllableCount };
+      const config = getConfig(langcode);
+      return texts.map((text) => {
+        const trimmed = text.trim();
+        if (!trimmed) return null;
+        const words = segmentWords(trimmed);
+        if (words.length < config.minWords) return null;
+        const score = safe(() => config.compute(trimmed, ctx));
+        return score != null ? round(score) : null;
+      });
+    },
+    classifyBand(score, langcode) {
+      return classifyBandGeneric(score, getConfig(langcode));
+    },
+    impactForScore(score, langcode) {
+      return impactForScoreGeneric(score, getConfig(langcode));
+    },
+    getAgentContext(langcode) {
+      return buildAgentContext(getConfig(langcode));
+    },
+    formatScore(value, langcode) {
+      const config = getConfig(langcode);
+      if (config.formatScore) {
+        return config.formatScore(value);
+      }
+      return Number.isFinite(value) ? value.toFixed(1) : String(value);
+    },
+    getScaleInfo(langcode) {
+      const config = getConfig(langcode);
+      const t1 = Math.min(config.bands.easy, config.bands.ok);
+      const t2 = Math.max(config.bands.easy, config.bands.ok);
+      const padding = Math.round((t2 - t1) * 0.5);
+      return {
+        thresholds: [t1, t2],
+        direction: config.direction,
+        scaleMin: Math.max(0, t1 - padding),
+        scaleMax: t2 + padding
+      };
+    }
+  };
+}

package/dist/modules/table-of-contents/index.d.mts

@@ -0,0 +1,12 @@
+import { B as BlokkliModule } from '../../shared/editor.D28NbXr3.mjs';
+import 'nuxt/schema';
+import 'consola';
+import '../../../dist/global/types/definitions.js';
+import '../../../dist/global/types/theme.js';
+import '../../../dist/global/types/colorOptions.js';
+import '@nuxt/kit';
+import '../../../dist/global/types/features.js';
+
+declare const _default: (options?: object | undefined) => BlokkliModule<object>;
+
+export { _default as default };