@jjlmoya/utils-motor 1.3.0 → 1.5.0

package/src/tool/motorcycleSkidMarkSpeedEstimator/controller.ts

@@ -0,0 +1,207 @@
+import { applyScene, buildSceneView, formatFriction, formatGrade, formatLength, lengthUnit } from './dom-views';
+import { evaluateSkid } from './evaluator';
+import {
+  clamp,
+  estimateSkidSpeed,
+  getSurfaceSpec,
+  isBrakeUse,
+  isSurfaceId,
+  isUnitSystem,
+  lengthToMeters,
+  MAX_FRICTION,
+  MAX_GRADE,
+  MAX_LENGTH_M,
+  MIN_FRICTION,
+  MIN_GRADE,
+  MIN_LENGTH_M,
+  parsePositiveNumber,
+  parseSignedNumber,
+  type BrakeUse,
+  type SkidInput,
+  type SurfaceId,
+  type UnitSystem,
+} from './logic';
+import { loadSkidState, saveSkidState } from './storage';
+
+type SkidUI = Record<string, string>;
+
+interface SkidState {
+  lengthMeters: number;
+  unit: UnitSystem;
+  surface: SurfaceId;
+  friction: number;
+  gradePercent: number;
+  brakeUse: BrakeUse;
+}
+
+const DEFAULT_STATE: SkidState = {
+  lengthMeters: 18,
+  unit: 'metric',
+  surface: 'dry-asphalt',
+  friction: 0.7,
+  gradePercent: 0,
+  brakeUse: 'both',
+};
+
+function toInput(state: SkidState): SkidInput {
+  return {
+    lengthMeters: state.lengthMeters,
+    friction: state.friction,
+    gradePercent: state.gradePercent,
+    surface: state.surface,
+    brakeUse: state.brakeUse,
+  };
+}
+
+function restoreState(): SkidState {
+  const saved = loadSkidState();
+  return saved ? { ...DEFAULT_STATE, ...saved } : { ...DEFAULT_STATE };
+}
+
+function queryEl(root: HTMLElement, selector: string): HTMLElement | null {
+  return root.querySelector(selector);
+}
+
+function queryInput(root: HTMLElement, selector: string): HTMLInputElement | null {
+  return root.querySelector(selector);
+}
+
+function bindHandle(root: HTMLElement, state: SkidState, ui: SkidUI): void {
+  const road = queryEl(root, '[data-trace-road]');
+  if (!road) return;
+  const move = (event: PointerEvent) => {
+    const box = road.getBoundingClientRect();
+    if (box.width <= 0) return;
+    const ratio = clamp((event.clientX - box.left) / box.width, 0.18, 0.92);
+    const meters = MIN_LENGTH_M + ((ratio - 0.18) / 0.74) * (MAX_LENGTH_M - MIN_LENGTH_M);
+    state.lengthMeters = clamp(meters, MIN_LENGTH_M, MAX_LENGTH_M);
+    render(root, state, ui);
+  };
+  road.addEventListener('pointerdown', (event) => {
+    const target = event.target;
+    if (target instanceof Element && target.closest('button, label, input, [data-brake-choice]')) return;
+    road.setPointerCapture(event.pointerId);
+    move(event);
+  });
+  road.addEventListener('pointermove', (event) => {
+    if (!road.hasPointerCapture(event.pointerId)) return;
+    move(event);
+  });
+}
+
+function markChoice(root: HTMLElement, attr: string, value: string, on: string): void {
+  root.querySelectorAll(`[${attr}]`).forEach((node) => {
+    node.classList.toggle(on, node.getAttribute(attr) === value);
+  });
+}
+
+function syncFields(root: HTMLElement, state: SkidState, ui: SkidUI): void {
+  const length = queryInput(root, '[data-trace-length]');
+  const grade = queryInput(root, '[data-trace-grade]');
+  const friction = queryInput(root, '[data-trace-friction]');
+  const frictionNumber = queryInput(root, '[data-trace-friction-number]');
+  const lengthUnitNode = queryEl(root, '[data-length-unit]');
+  const gradeValue = queryEl(root, '[data-grade-value]');
+  if (length) length.value = formatLength(state.lengthMeters, state.unit);
+  if (grade) grade.value = String(state.gradePercent);
+  if (friction) friction.value = formatFriction(state.friction);
+  if (frictionNumber) frictionNumber.value = formatFriction(state.friction);
+  if (lengthUnitNode) lengthUnitNode.textContent = lengthUnit(ui, state.unit);
+  if (gradeValue) gradeValue.textContent = `${formatGrade(state.gradePercent)}${ui.percentSuffix ?? '%'}`;
+  root.dataset.unit = state.unit;
+  root.dataset.brake = state.brakeUse;
+  markChoice(root, 'data-unit-choice', state.unit, 'is-stencil');
+  markChoice(root, 'data-surface-choice', state.surface, 'is-core');
+  markChoice(root, 'data-brake-choice', state.brakeUse, 'is-lock');
+}
+
+function render(root: HTMLElement, state: SkidState, ui: SkidUI): void {
+  const input = toInput(state);
+  root.dataset.eval = evaluateSkid(input);
+  applyScene(root, buildSceneView(input, estimateSkidSpeed(input), state.unit, ui));
+  syncFields(root, state, ui);
+  saveSkidState(state);
+}
+
+function onLengthInput(state: SkidState, raw: string): void {
+  const parsed = parsePositiveNumber(raw);
+  if (parsed === null) return;
+  state.lengthMeters = clamp(lengthToMeters(parsed, state.unit), MIN_LENGTH_M, MAX_LENGTH_M);
+}
+
+function onGradeInput(state: SkidState, raw: string): void {
+  const parsed = parseSignedNumber(raw);
+  if (parsed === null) return;
+  state.gradePercent = clamp(parsed, MIN_GRADE, MAX_GRADE);
+}
+
+function onFrictionInput(state: SkidState, raw: string): void {
+  const parsed = parsePositiveNumber(raw);
+  if (parsed === null) return;
+  state.friction = clamp(parsed, MIN_FRICTION, MAX_FRICTION);
+  state.surface = 'custom';
+}
+
+function onSurfaceChoice(state: SkidState, raw: string): void {
+  if (!isSurfaceId(raw)) return;
+  state.surface = raw;
+  if (raw === 'custom') return;
+  state.friction = getSurfaceSpec(raw).mu;
+}
+
+function onUnitChoice(state: SkidState, raw: string): void {
+  if (!isUnitSystem(raw)) return;
+  state.unit = raw;
+}
+
+function onBrakeChoice(state: SkidState, raw: string): void {
+  if (!isBrakeUse(raw)) return;
+  state.brakeUse = raw;
+}
+
+function bindClicks(root: HTMLElement, attr: string, apply: (value: string) => void): void {
+  root.querySelectorAll(`[${attr}]`).forEach((node) => {
+    node.addEventListener('click', (event) => {
+      event.stopPropagation();
+      const value = node.getAttribute(attr);
+      if (value) apply(value);
+    });
+  });
+}
+
+function bindNumber(
+  root: HTMLElement,
+  bind: { selector: string; apply: (raw: string) => void; state: SkidState; ui: SkidUI },
+): void {
+  const input = queryInput(root, bind.selector);
+  input?.addEventListener('input', () => {
+    bind.apply(input.value);
+    render(root, bind.state, bind.ui);
+  });
+}
+
+function bindInputs(root: HTMLElement, state: SkidState, ui: SkidUI): void {
+  bindNumber(root, { selector: '[data-trace-length]', apply: (raw) => onLengthInput(state, raw), state, ui });
+  bindNumber(root, { selector: '[data-trace-grade]', apply: (raw) => onGradeInput(state, raw), state, ui });
+  bindNumber(root, { selector: '[data-trace-friction]', apply: (raw) => onFrictionInput(state, raw), state, ui });
+  bindNumber(root, { selector: '[data-trace-friction-number]', apply: (raw) => onFrictionInput(state, raw), state, ui });
+}
+
+export function mountSkidEstimator(root: HTMLElement, ui: SkidUI): void {
+  const state = restoreState();
+  bindInputs(root, state, ui);
+  bindClicks(root, 'data-unit-choice', (value) => {
+    onUnitChoice(state, value);
+    render(root, state, ui);
+  });
+  bindClicks(root, 'data-surface-choice', (value) => {
+    onSurfaceChoice(state, value);
+    render(root, state, ui);
+  });
+  bindClicks(root, 'data-brake-choice', (value) => {
+    onBrakeChoice(state, value);
+    render(root, state, ui);
+  });
+  bindHandle(root, state, ui);
+  render(root, state, ui);
+}

package/src/tool/motorcycleSkidMarkSpeedEstimator/dom-views.ts

@@ -0,0 +1,101 @@
+import {
+  gradeTilt,
+  markRatio,
+  metersToLength,
+  speedFromMps,
+  type SkidEstimate,
+  type SkidInput,
+  type UnitSystem,
+} from './logic';
+
+function uiText(ui: Record<string, string>, key: string): string {
+  return ui[key] ?? '';
+}
+
+export function formatSpeed(mps: number, unit: UnitSystem): string {
+  const value = speedFromMps(mps, unit);
+  return value >= 100 ? value.toFixed(0) : value.toFixed(1);
+}
+
+export function formatLength(meters: number, unit: UnitSystem): string {
+  return metersToLength(meters, unit).toFixed(1);
+}
+
+export function formatFriction(value: number): string {
+  return value.toFixed(2);
+}
+
+export function formatGrade(value: number): string {
+  if (Object.is(value, -0) || value === 0) return '0';
+  return value.toFixed(0);
+}
+
+export function speedUnit(ui: Record<string, string>, unit: UnitSystem): string {
+  return unit === 'imperial' ? uiText(ui, 'stencilUnitMph') : uiText(ui, 'stencilUnitKmh');
+}
+
+export function lengthUnit(ui: Record<string, string>, unit: UnitSystem): string {
+  return unit === 'imperial' ? uiText(ui, 'lengthUnitFt') : uiText(ui, 'lengthUnitM');
+}
+
+export function gradeCaption(gradePercent: number, ui: Record<string, string>): string {
+  if (gradePercent > 0) return uiText(ui, 'gradeUphill');
+  if (gradePercent < 0) return uiText(ui, 'gradeDownhill');
+  return uiText(ui, 'gradeLevel');
+}
+
+export function formatRange(lowMps: number, highMps: number, unit: UnitSystem): string {
+  return `${formatSpeed(lowMps, unit)} to ${formatSpeed(highMps, unit)}`;
+}
+
+export interface SceneView {
+  tilt: number;
+  needle: number;
+  mark: number;
+  surface: string;
+  speedText: string;
+  rangeText: string;
+}
+
+function emptyScene(input: SkidInput, ui: Record<string, string>): SceneView {
+  return {
+    tilt: gradeTilt(input.gradePercent),
+    needle: input.gradePercent * 1.7,
+    mark: markRatio(input.lengthMeters),
+    surface: input.surface,
+    speedText: uiText(ui, 'invalidMessage'),
+    rangeText: '',
+  };
+}
+
+export function buildSceneView(
+  input: SkidInput,
+  estimate: SkidEstimate,
+  unit: UnitSystem,
+  ui: Record<string, string>,
+): SceneView {
+  if (estimate.status === 'invalid' || !estimate.band) return emptyScene(input, ui);
+  const unitLabel = speedUnit(ui, unit);
+  return {
+    tilt: gradeTilt(input.gradePercent),
+    needle: input.gradePercent * 1.7,
+    mark: markRatio(input.lengthMeters),
+    surface: input.surface,
+    speedText: `${formatSpeed(estimate.band.midMps, unit)} ${unitLabel}`,
+    rangeText: `${formatRange(estimate.band.lowMps, estimate.band.highMps, unit)} ${unitLabel}`,
+  };
+}
+
+export function applyScene(root: HTMLElement, view: SceneView): void {
+  root.dataset.surface = view.surface;
+  root.style.setProperty('--trace-tilt', `${view.tilt}deg`);
+  root.style.setProperty('--trace-needle', `${view.needle}deg`);
+  root.style.setProperty('--trace-span', view.mark.toFixed(3));
+  writeText(root, '[data-trace-speed]', view.speedText);
+  writeText(root, '[data-trace-range]', view.rangeText);
+}
+
+function writeText(root: HTMLElement, selector: string, text: string): void {
+  const node = root.querySelector(selector);
+  if (node) node.textContent = text;
+}

package/src/tool/motorcycleSkidMarkSpeedEstimator/entry.ts

@@ -0,0 +1,30 @@
+import type { MotorToolEntry, ToolLocaleContent } from '../../types';
+import type { MotorcycleSkidMarkSpeedEstimatorUI } from './ui';
+
+export type { MotorcycleSkidMarkSpeedEstimatorUI };
+export type MotorcycleSkidMarkSpeedEstimatorLocaleContent = ToolLocaleContent<MotorcycleSkidMarkSpeedEstimatorUI>;
+
+export const motorcycleSkidMarkSpeedEstimator: MotorToolEntry<MotorcycleSkidMarkSpeedEstimatorUI> = {
+  id: 'motorcycle-skid-mark-speed-estimator',
+  icons: {
+    bg: 'mdi:motorbike',
+    fg: 'mdi:road',
+  },
+  i18n: {
+    de: () => import('./i18n/de').then((module) => module.content),
+    en: () => import('./i18n/en').then((module) => module.content),
+    es: () => import('./i18n/es').then((module) => module.content),
+    fr: () => import('./i18n/fr').then((module) => module.content),
+    id: () => import('./i18n/id').then((module) => module.content),
+    it: () => import('./i18n/it').then((module) => module.content),
+    ja: () => import('./i18n/ja').then((module) => module.content),
+    ko: () => import('./i18n/ko').then((module) => module.content),
+    nl: () => import('./i18n/nl').then((module) => module.content),
+    pl: () => import('./i18n/pl').then((module) => module.content),
+    pt: () => import('./i18n/pt').then((module) => module.content),
+    ru: () => import('./i18n/ru').then((module) => module.content),
+    sv: () => import('./i18n/sv').then((module) => module.content),
+    tr: () => import('./i18n/tr').then((module) => module.content),
+    zh: () => import('./i18n/zh').then((module) => module.content),
+  },
+};

package/src/tool/motorcycleSkidMarkSpeedEstimator/evaluator.ts

@@ -0,0 +1,7 @@
+import { estimateSkidSpeed, type SkidEstimate, type SkidInput } from './logic';
+
+export type SkidEvaluation = SkidEstimate['status'];
+
+export function evaluateSkid(input: SkidInput): SkidEvaluation {
+  return estimateSkidSpeed(input).status;
+}

package/src/tool/motorcycleSkidMarkSpeedEstimator/i18n/de.ts

@@ -0,0 +1,185 @@
+import type { FAQPage, HowTo, SoftwareApplication, WithContext } from 'schema-dts';
+import type { SEOSection } from '@jjlmoya/utils-shared';
+import { bibliographyEntries } from '../bibliography';
+import type { MotorcycleSkidMarkSpeedEstimatorLocaleContent } from '../entry';
+
+const slug = 'motorrad-bremsspur-geschwindigkeitsrechner';
+const title = 'Motorrad Bremsspur Geschwindigkeitsrechner';
+const description =
+  'Schätzen Sie die Motorradgeschwindigkeit anhand der Bremsspurlänge, Straßenreibung, Steigung und Bremsart. Ein lehrreiches Physikmodell zur Unfallanalyse.';
+
+const faq = [
+  {
+    question: 'Welche Geschwindigkeit zeigt eine Bremsspur an?',
+    answer:
+      'Eine blockierte Reifenbremsspur misst die Distanz zur Umwandlung von kinetischer Energie in Reibungswärme. Die physikalische Energiegleichung ermittelt die Mindestgeschwindigkeit zu Beginn der sichtbaren Spur und nicht die ursprüngliche Fahrgeschwindigkeit vor Betätigung der Bremse.',
+  },
+  {
+    question: 'Warum wird ein Geschwindigkeitsbereich angegeben?',
+    answer:
+      'Reibwerte von Straßenbelägen unterliegen Schwankungen, und die Bremskraftverteilung zwischen Vorder- und Hinterrad variiert je nach Fahrer. Der Rechner ermittelt daher Unter-, Mittel- und Oberwerte für eine realistische Einschätzung der Messunsicherheit.',
+  },
+  {
+    question: 'Ist das Ergebnis als offizielles Unfallgutachten zulässig?',
+    answer:
+      'Nein. Ein gerichtsfestes Gutachten erfordert Messungen mit einem Verzögerungsschlitten vor Ort, Spuridentifizierung, ABS-Verhaltensanalysen und Sachverständige. Diese Anwendung dient ausschließlich als physikalisches Lernmodell.',
+  },
+  {
+    question: 'Wie unterscheidet sich dies von einem Bremswegrechner?',
+    answer:
+      'Ein klassischer Bremswegrechner geht von einer bekannten Geschwindigkeit aus und berechnet den Anhalteweg. Dieses Werkzeug rechnet umgekehrt von einer gemessenen Reifenspur auf die Ausgangsgeschwindigkeit zurück.',
+  },
+];
+
+const howTo = [
+  { name: 'Spur messen', text: 'Messen Sie die sichtbare Blockierspur des Reifenabriebs präzise in Metern oder Fuß.' },
+  { name: 'Fahrbahn wählen', text: 'Wählen Sie den entsprechenden Straßenbelag oder geben Sie einen gemessenen Reibwert manuell ein.' },
+  { name: 'Neigung und Bremse einstellen', text: 'Geben Sie die Steigung der Straße an und wählen Sie, welche Räder blockiert haben.' },
+  { name: 'Ergebnis ablesen', text: 'Nutzen Sie den Mittelwert als Richtwert und beachten Sie die angezeigte Schwankungsbreite.' },
+];
+
+const seo: SEOSection[] = [
+  { type: 'title', level: 2, text: 'Aus einer Reifenabriebspur die Geschwindigkeit berechnen' },
+  {
+    type: 'paragraph',
+    html: 'Ein Motorrad hinterlässt bei einer Gefahrenbremsung häufig eine deutliche Spur des Hinterrades, eine schwächere Linie des Vorderrades oder eine unterbrochene ABS-Spur. Gemessen wird ausschließlich der Bereich mit vollständig blockiertem Reifen, nicht jedoch das spätere Rutschen des Motorrads auf der Verkleidung nach einem Sturz.',
+  },
+  { type: 'title', level: 3, text: 'Physikalische Grundlagen der Geschwindigkeitsbestimmung' },
+  {
+    type: 'paragraph',
+    html: 'Das zugrundeliegende Modell nutzt die Energiebilanz des Rutschvorgangs: Die Geschwindigkeit entspricht der Quadratwurzel aus dem zweifachen Produkt der Erdbeschleunigung, des Reibungsbeiwerts und der gemessenen Spurlänge. Die Steigung der Fahrbahn fließt als Vektorkomponente ein. Eine Steigung unterstützt die Bremsung, während ein Gefälle den Bremsweg verlängert.',
+  },
+  {
+    type: 'list',
+    items: [
+      'Alle Längenangaben werden intern exakt in Meter umgerechnet.',
+      'Integrierte Richtwerte für trockenen und nassen Asphalt, Beton, Schotter und Eis.',
+      'Berücksichtigung der Achslastverlagerung bei reiner Vorder- oder Hinterradbremsung.',
+      'Bei unbestimmter Bremsung wird die Spanne von der günstigsten bis zur ungünstigsten Annahme erweitert.',
+    ],
+  },
+  {
+    type: 'tip',
+    title: 'Nur den blockierten Reifenabschnitt messen',
+    html: 'Beginnen Sie die Messung am ersten sichtbaren Reifenabrieb und beenden Sie sie dort, wo das Rad wieder rollt oder der Aufprall stattfindet. Addieren Sie nicht die Rutschstrecke des Motorrads auf der Karosserie.',
+  },
+  { type: 'title', level: 3, text: 'Typische Reibbeiwerte im Straßenverkehr' },
+  {
+    type: 'table',
+    headers: ['Oberfläche', 'Mittlerer Reibbeiwert', 'Schwankungsbereich'],
+    rows: [
+      ['Trockener Asphalt', '0.70', '0.55 bis 0.85'],
+      ['Nasser Asphalt', '0.50', '0.35 bis 0.65'],
+      ['Trockener Beton', '0.75', '0.60 bis 0.90'],
+      ['Kies oder Schotter', '0.50', '0.35 bis 0.70'],
+      ['Erde oder Gras', '0.40', '0.25 bis 0.55'],
+      ['Eisfläche', '0.10', '0.05 bis 0.18'],
+    ],
+  },
+  {
+    type: 'paragraph',
+    html: 'Diese Werte dienen der Veranschaulichung des Reibungsverhaltens blockierter Gummireifen auf unterschiedlichen Untergründen. Eine messtechnische Bestimmung vor Ort ist Tabellenwerten stets vorzuziehen.',
+  },
+  { type: 'title', level: 3, text: 'Besonderheiten des Motorrad-Bremssystems' },
+  {
+    type: 'paragraph',
+    html: 'Da Motorräder getrennte Bremsbetätigungen für Vorder- und Hinterrad besitzen, erlaubt eine reine Hinterradspur keinen Rückschluss auf die Ausnutzung des Gesamtpotenzials. Der Rechner ermöglicht daher die getrennte Auswertung der Achsen.',
+  },
+  {
+    type: 'diagnostic',
+    variant: 'warning',
+    title: 'Didaktisches Physikmodell',
+    badge: 'Lehrmodell',
+    html: 'ABS-Intervalle, Reifenverschleiß, Beladung und Aufprallenergie verändern die tatsächliche Ausgangsgeschwindigkeit. Bei extremem Gefälle stoppt das Modell die Berechnung aufgrund physikalischer Unmöglichkeit.',
+  },
+];
+
+const schemas: WithContext<SoftwareApplication | FAQPage | HowTo>[] = [
+  {
+    '@context': 'https://schema.org',
+    '@type': 'SoftwareApplication',
+    name: title,
+    applicationCategory: 'UtilitiesApplication',
+    operatingSystem: 'Web',
+    offers: { '@type': 'Offer', price: '0', priceCurrency: 'EUR' },
+    description,
+  },
+  {
+    '@context': 'https://schema.org',
+    '@type': 'FAQPage',
+    mainEntity: faq.map((item) => ({
+      '@type': 'Question',
+      name: item.question,
+      acceptedAnswer: { '@type': 'Answer', text: item.answer },
+    })),
+  },
+  {
+    '@context': 'https://schema.org',
+    '@type': 'HowTo',
+    name: title,
+    step: howTo.map((step) => ({
+      '@type': 'HowToStep',
+      name: step.name,
+      text: step.text,
+    })),
+  },
+];
+
+export const content: MotorcycleSkidMarkSpeedEstimatorLocaleContent = {
+  slug,
+  title,
+  description,
+  ui: {
+    unitMetric: 'Metrisch',
+    unitImperial: 'Imperial',
+    disclaimer: 'Nur für Bildungs- und Unterrichtszwecke.',
+    lengthLabel: 'Spurlänge',
+    lengthHint: 'Ziehen Sie die Bremsspur auf der Fahrbahn.',
+    gradeLabel: 'Steigung',
+    gradeHint: 'Bergan hilft beim Bremsen, bergab verlängert den Weg.',
+    surfaceLabel: 'Fahrbahnbelag',
+    frictionLabel: 'Reibwert',
+    frictionHint: 'Wählen Sie einen Belag oder geben Sie den Reibbeiwert an.',
+    brakeLabel: 'Blockiertes Rad',
+    brakeBoth: 'Beide Räder',
+    brakeFront: 'Vorderrad',
+    brakeRear: 'Hinterrad',
+    brakeUnknown: 'Unbekannt',
+    speedLabel: 'Geschwindigkeit auf der Spur',
+    rangeLabel: 'Toleranzbereich',
+    dragHint: 'Ziehen Sie die Spur auf der Fahrbahn.',
+    emptyMessage: 'Ziehen Sie die Spur zur Geschwindigkeitsberechnung.',
+    invalidMessage: 'Zu steiles Gefälle. Bremsung physikalisch nicht möglich.',
+    readyMessage: 'Geschwindigkeit berechnet.',
+    educationalBadge: 'Lehrmodell',
+    surfaceDryAsphalt: 'Trockener Asphalt',
+    surfaceWetAsphalt: 'Nasser Asphalt',
+    surfaceDryConcrete: 'Trockener Beton',
+    surfaceGravel: 'Kies',
+    surfaceGrass: 'Erde',
+    surfaceIce: 'Eis',
+    surfaceCustom: 'Manuell',
+    sensitivityLabel: 'Schätzbereich',
+    lowAssumption: 'Niedrig',
+    highAssumption: 'Hoch',
+    gradeUphill: 'Steigung',
+    gradeDownhill: 'Gefälle',
+    gradeLevel: 'Eben',
+    measureHint: 'Vor-Ort-Messungen ersetzen Richtwerttabellen.',
+    stencilUnitKmh: 'km/h',
+    stencilUnitMph: 'mph',
+    lengthUnitM: 'm',
+    lengthUnitFt: 'ft',
+    percentSuffix: '%',
+    dragLowLabel: 'Geringe Reibung',
+    dragMidLabel: 'Mittlere Reibung',
+    dragHighLabel: 'Hohe Reibung',
+  },
+  seo,
+  faqTitle: 'Häufige Fragen zur Bremsspurberechnung',
+  faq,
+  bibliographyTitle: 'Quellen',
+  bibliography: bibliographyEntries,
+  howTo,
+  schemas,
+};