kennzeichen 0.1.0

package/dist/core/index.d.ts

@@ -0,0 +1,99 @@
+/**
+ * A parsed German license plate with its three components.
+ * Example: "M-AB 1234" -> { part1: "M", part2: "AB", part3: "1234" }
+ */
+type ParsedPlate = {
+    part1: string;
+    part2: string;
+    part3: string;
+};
+/**
+ * Result of parsing a license plate input.
+ */
+type ParseResult = {
+    type: "unambiguous";
+    plate: ParsedPlate;
+} | {
+    type: "ambiguous";
+    options: ParsedPlate[];
+} | {
+    type: "partial";
+    plate: Partial<ParsedPlate>;
+} | {
+    type: "invalid";
+};
+
+/**
+ * All valid German license plate location codes (Unterscheidungszeichen).
+ * 726 codes including umlauts (Ä, Ö, Ü).
+ */
+declare const LOCATION: readonly ["A", "AA", "AB", "ABG", "ABI", "AC", "AE", "AH", "AIB", "AIC", "AK", "ALF", "ALZ", "AM", "AN", "ANA", "ANG", "ANK", "AÖ", "AP", "APD", "ARN", "ART", "AS", "ASL", "ASZ", "AT", "AU", "AUR", "AW", "AZ", "AZE", "B", "BA", "BAD", "BAR", "BB", "BBG", "BBL", "BC", "BCH", "BD", "BE", "BED", "BER", "BF", "BGD", "BGL", "BH", "BI", "BID", "BIN", "BIR", "BIT", "BIW", "BK", "BKS", "BL", "BLB", "BLK", "BM", "BN", "BNA", "BO", "BÖ", "BOG", "BOH", "BOR", "BOT", "BP", "BRA", "BRB", "BRG", "BRK", "BRL", "BRV", "BS", "BSB", "BSK", "BT", "BTF", "BÜD", "BUL", "BÜR", "BÜS", "BÜZ", "BW", "BWL", "BYL", "BZ", "C", "CA", "CAS", "CB", "CE", "CHA", "CLP", "CLZ", "CO", "COC", "COE", "CR", "CUX", "CW", "D", "DA", "DAH", "DAN", "DAU", "DBR", "DD", "DE", "DEG", "DEL", "DGF", "DH", "DI", "DIL", "DIN", "DIZ", "DKB", "DL", "DLG", "DM", "DN", "DO", "DON", "DU", "DUD", "DÜW", "DW", "DZ", "E", "EA", "EB", "EBE", "EBN", "EBS", "ECK", "ED", "EE", "EF", "EG", "EH", "EI", "EIC", "EIL", "EIN", "EIS", "EL", "EM", "EMD", "EMS", "EN", "ER", "ERB", "ERH", "ERK", "ERZ", "ES", "ESB", "ESW", "EU", "EW", "F", "FB", "FD", "FDB", "FDS", "FEU", "FF", "FFB", "FG", "FI", "FKB", "FL", "FLÖ", "FN", "FO", "FOR", "FR", "FRG", "FRI", "FRW", "FS", "FT", "FTL", "FÜ", "FÜS", "FW", "FZ", "G", "GA", "GAN", "GAP", "GC", "GD", "GDB", "GE", "GEL", "GEO", "GER", "GF", "GG", "GHA", "GHC", "GI", "GK", "GL", "GLA", "GM", "GMN", "GN", "GNT", "GÖ", "GOA", "GOH", "GP", "GR", "GRA", "GRH", "GRI", "GRM", "GRZ", "GS", "GT", "GTH", "GÜ", "GUB", "GUN", "GV", "GVM", "GW", "GZ", "H", "HA", "HAB", "HAL", "HAM", "HAS", "HB", "HBN", "HBS", "HC", "HCH", "HD", "HDH", "HDL", "HE", "HEB", "HEF", "HEI", "HEL", "HER", "HET", "HF", "HG", "HGN", "HGW", "HH", "HHM", "HI", "HIG", "HIP", "HK", "HL", "HM", "HMÜ", "HN", "HO", "HOG", "HOH", "HOL", "HOM", "HOR", "HÖS", "HOT", "HP", "HR", "HRO", "HS", "HSK", "HST", "HU", "HV", "HVL", "HWI", "HX", "HY", "HZ", "IGB", "IK", "IL", "ILL", "IN", "IZ", "J", "JE", "JL", "JÜL", "K", "KA", "KB", "KC", "KE", "KEH", "KEL", "KEM", "KF", "KG", "KH", "KI", "KIB", "KK", "KL", "KLE", "KLZ", "KM", "KN", "KO", "KÖN", "KÖT", "KÖZ", "KR", "KRU", "KS", "KT", "KU", "KÜN", "KUS", "KW", "KY", "KYF", "L", "LA", "LAN", "LAU", "LB", "LBS", "LBZ", "LC", "LD", "LDK", "LDS", "LEO", "LER", "LEV", "LF", "LG", "LH", "LI", "LIB", "LIF", "LIP", "LL", "LM", "LN", "LÖ", "LÖB", "LOS", "LP", "LR", "LRO", "LSA", "LSN", "LSZ", "LU", "LÜN", "LUP", "LWL", "M", "MA", "MAB", "MAI", "MAK", "MAL", "MB", "MC", "MD", "ME", "MED", "MEG", "MEI", "MEK", "MEL", "MER", "MET", "MG", "MGH", "MGN", "MH", "MHL", "MI", "MIL", "MK", "MKK", "ML", "MM", "MN", "MO", "MOD", "MOL", "MON", "MOS", "MQ", "MR", "MS", "MSE", "MSH", "MSP", "MST", "MTK", "MTL", "MUC", "MÜ", "MÜB", "MÜL", "MÜR", "MVL", "MW", "MY", "MYK", "MZ", "MZG", "N", "NAB", "NAI", "NAU", "NB", "ND", "NDH", "NE", "NEA", "NEB", "NEC", "NEN", "NES", "NEU", "NEW", "NF", "NH", "NI", "NK", "NL", "NM", "NMB", "NMS", "NÖ", "NOH", "NOL", "NOM", "NOR", "NP", "NR", "NRW", "NT", "NU", "NVP", "NW", "NWM", "NY", "NZ", "OA", "OAL", "OB", "OBB", "OBG", "OC", "OCH", "OD", "OE", "OF", "OG", "OH", "OHA", "ÖHR", "OHV", "OHZ", "OK", "OL", "OP", "OPR", "OS", "OSL", "OTW", "OVI", "OVL", "OVP", "OZ", "P", "PA", "PAF", "PAN", "PAR", "PB", "PCH", "PE", "PEG", "PF", "PI", "PIR", "PL", "PLÖ", "PM", "PN", "PR", "PRÜ", "PS", "PW", "PZ", "QFT", "QLB", "R", "RA", "RC", "RD", "RDG", "RE", "REG", "REH", "REI", "RG", "RH", "RI", "RID", "RIE", "RL", "RM", "RN", "RO", "ROD", "ROF", "ROK", "ROL", "ROS", "ROT", "ROW", "RP", "RPL", "RS", "RSL", "RT", "RU", "RÜD", "RÜG", "RV", "RW", "RZ", "S", "SAB", "SAD", "SAL", "SAN", "SAW", "SÄK", "SB", "SBG", "SBK", "SC", "SCZ", "SDH", "SDL", "SDT", "SE", "SEB", "SEE", "SEF", "SEL", "SFB", "SFT", "SG", "SGH", "SH", "SHA", "SHG", "SHK", "SHL", "SI", "SIG", "SIH", "SIM", "SK", "SL", "SLE", "SLF", "SLG", "SLK", "SLN", "SLS", "SLÜ", "SLZ", "SM", "SMÜ", "SN", "SO", "SOB", "SOG", "SOK", "SÖM", "SON", "SP", "SPB", "SPN", "SR", "SRB", "SRO", "ST", "STA", "STB", "STD", "STE", "STL", "STO", "SU", "SUL", "SÜW", "SW", "SWA", "SY", "SZ", "SZB", "TBB", "TDO", "TE", "TET", "TF", "TG", "THL", "THW", "TIR", "TO", "TÖL", "TP", "TR", "TS", "TT", "TÜ", "TUT", "UE", "UEM", "UFF", "UH", "UL", "UM", "UN", "USI", "ÜB", "V", "VAI", "VB", "VEC", "VER", "VG", "VIB", "VIE", "VIT", "VK", "VOH", "VR", "VS", "W", "WA", "WAF", "WAK", "WAN", "WAR", "WAT", "WB", "WBS", "WDA", "WE", "WEL", "WEN", "WER", "WES", "WF", "WG", "WHV", "WI", "WIL", "WIN", "WIS", "WIT", "WIV", "WIZ", "WK", "WL", "WLG", "WM", "WMS", "WN", "WND", "WO", "WOB", "WOH", "WOL", "WOR", "WOS", "WR", "WRN", "WS", "WSF", "WST", "WSW", "WT", "WTL", "WTM", "WÜ", "WUG", "WÜM", "WUN", "WUR", "WW", "WZ", "WZL", "X", "Y", "Z", "ZE", "ZEL", "ZI", "ZIG", "ZP", "ZR", "ZW", "ZZ"];
+type LocationCode = (typeof LOCATION)[number];
+/**
+ * Set of valid location codes for O(1) lookup.
+ */
+declare const LOCATION_SET: Set<string>;
+
+/**
+ * Parses a license plate input string into its component parts.
+ * Handles various input formats:
+ * - With hyphen: "M-AB 1234"
+ * - With spaces: "M AB 1234"
+ * - Without separators: "MAB1234"
+ *
+ * @returns ParseResult with one of:
+ * - unambiguous: single valid interpretation
+ * - ambiguous: multiple valid interpretations (user must choose)
+ * - partial: incomplete but valid so far
+ * - invalid: cannot be parsed
+ */
+declare function parseLicensePlate(input: string): ParseResult;
+
+/**
+ * Formats a parsed plate into the standard display format: "M-AB 1234"
+ */
+declare function formatParsedPlate(plate: Partial<ParsedPlate>): string;
+/**
+ * Formats a raw license plate string into the standard display format.
+ * Expects input like "M-AB1234" or "M-AB 1234" and returns "M-AB 1234".
+ * Returns the original input if it can't be parsed.
+ */
+declare function formatPlateNo(input: string): string;
+
+/**
+ * Removes all spaces and hyphens from a license plate string.
+ * Useful for storing or comparing plates in a normalized form.
+ *
+ * @example
+ * sanitizeLicensePlate("M-AB 1234") // "MAB1234"
+ */
+declare function sanitizeLicensePlate(plate: string): string;
+/**
+ * Alias for sanitizeLicensePlate.
+ * Removes all spaces and hyphens from a license plate string.
+ */
+declare function cleanPlateNo(input: string): string;
+/**
+ * Checks if a license plate string is valid (unambiguously parseable).
+ *
+ * @example
+ * isValidLicensePlate("M-AB 1234") // true
+ * isValidLicensePlate("XX-AB 1234") // false (invalid location)
+ * isValidLicensePlate("MAB1234") // true (can be unambiguously parsed)
+ */
+declare function isValidLicensePlate(input: string): boolean;
+/**
+ * Simple regex-based validation for formatted German license plates.
+ * Expects format: "LOC-XX 1234" or "LOC-XX 1234E/H"
+ *
+ * This is a lighter-weight check that doesn't validate the location code
+ * against the full list. Use isValidLicensePlate() for full validation.
+ *
+ * @example
+ * isValidLicensePlateFormat("M-AB 1234") // true
+ * isValidLicensePlateFormat("XX-AB 1234") // true (doesn't check location)
+ * isValidLicensePlateFormat("MAB1234") // false (wrong format)
+ */
+declare function isValidLicensePlateFormat(input: string): boolean;
+
+export { LOCATION, LOCATION_SET, type LocationCode, type ParseResult, type ParsedPlate, cleanPlateNo, formatParsedPlate, formatPlateNo, isValidLicensePlate, isValidLicensePlateFormat, parseLicensePlate, sanitizeLicensePlate };

package/dist/core/index.js

@@ -0,0 +1,22 @@
+import {
+  LOCATION,
+  LOCATION_SET,
+  cleanPlateNo,
+  formatParsedPlate,
+  formatPlateNo,
+  isValidLicensePlate,
+  isValidLicensePlateFormat,
+  parseLicensePlate,
+  sanitizeLicensePlate
+} from "../chunk-WNVAHMV3.js";
+export {
+  LOCATION,
+  LOCATION_SET,
+  cleanPlateNo,
+  formatParsedPlate,
+  formatPlateNo,
+  isValidLicensePlate,
+  isValidLicensePlateFormat,
+  parseLicensePlate,
+  sanitizeLicensePlate
+};

package/dist/react/index.d.ts

@@ -0,0 +1,143 @@
+import { ParseResult, ParsedPlate } from '../core/index.js';
+export { LOCATION, LOCATION_SET, LocationCode, cleanPlateNo, formatParsedPlate, formatPlateNo, isValidLicensePlate, isValidLicensePlateFormat, parseLicensePlate, sanitizeLicensePlate } from '../core/index.js';
+import { ReactNode } from 'react';
+
+interface UseLicensePlateOptions {
+    /** Controlled value */
+    value?: string;
+    /** Called when the value changes */
+    onChange?: (value: string) => void;
+    /** Called when the input loses focus */
+    onBlur?: () => void;
+}
+interface UseLicensePlateReturn {
+    /** Current input value */
+    inputValue: string;
+    /** Current parse result */
+    parseResult: ParseResult;
+    /** Handler for input onChange event */
+    handleChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    /** Handler for input onKeyDown event (for dropdown navigation) */
+    handleKeyDown: (e: React.KeyboardEvent<HTMLInputElement>) => void;
+    /** Handler for input onBlur event */
+    handleBlur: () => void;
+    /** Whether the disambiguation dropdown should be open */
+    isDropdownOpen: boolean;
+    /** Available options when input is ambiguous (null otherwise) */
+    options: ParsedPlate[] | null;
+    /** Currently highlighted option index */
+    activeIndex: number;
+    /** Select a specific option from the disambiguation dropdown */
+    selectOption: (option: ParsedPlate) => void;
+    /** Set the active (highlighted) option index */
+    setActiveIndex: (index: number) => void;
+}
+/**
+ * React hook for managing license plate input state.
+ * Handles parsing, formatting, and disambiguation.
+ *
+ * @example
+ * ```tsx
+ * function MyInput() {
+ *   const lp = useLicensePlate({ value, onChange })
+ *
+ *   return (
+ *     <div>
+ *       <input
+ *         value={lp.inputValue}
+ *         onChange={lp.handleChange}
+ *         onKeyDown={lp.handleKeyDown}
+ *         onBlur={lp.handleBlur}
+ *       />
+ *       {lp.isDropdownOpen && lp.options && (
+ *         <ul>
+ *           {lp.options.map((opt, i) => (
+ *             <li
+ *               key={i}
+ *               className={i === lp.activeIndex ? 'active' : ''}
+ *               onClick={() => lp.selectOption(opt)}
+ *             >
+ *               {formatParsedPlate(opt)}
+ *             </li>
+ *           ))}
+ *         </ul>
+ *       )}
+ *     </div>
+ *   )
+ * }
+ * ```
+ */
+declare function useLicensePlate(options?: UseLicensePlateOptions): UseLicensePlateReturn;
+
+interface InputProps {
+    value: string;
+    onChange: (e: React.ChangeEvent<HTMLInputElement>) => void;
+    onKeyDown: (e: React.KeyboardEvent<HTMLInputElement>) => void;
+    onBlur: () => void;
+}
+interface OptionProps {
+    onClick: () => void;
+    onMouseDown: (e: React.MouseEvent) => void;
+    onMouseEnter: () => void;
+}
+interface OptionItem {
+    /** The parsed plate data */
+    plate: ParsedPlate;
+    /** Pre-formatted display string (e.g., "M-AB 1234") */
+    formatted: string;
+    /** Whether this option is currently highlighted */
+    isActive: boolean;
+    /** Get props to spread on the option element */
+    getProps: () => OptionProps;
+}
+interface RenderProps {
+    /** Props to spread on the input element */
+    inputProps: InputProps;
+    /** Whether the disambiguation dropdown should be visible */
+    isOpen: boolean;
+    /** Disambiguation options (null when not ambiguous) */
+    options: OptionItem[] | null;
+    /** Current parse result */
+    parseResult: ParseResult;
+}
+interface LicensePlateInputProps {
+    /** Controlled value */
+    value?: string;
+    /** Called when the value changes */
+    onChange?: (value: string) => void;
+    /** Called when the input loses focus */
+    onBlur?: () => void;
+    /** Render function that receives the headless props */
+    children: (props: RenderProps) => ReactNode;
+}
+/**
+ * Headless license plate input component using render props.
+ * Provides all the state and handlers needed to build a license plate input.
+ *
+ * @example
+ * ```tsx
+ * <LicensePlateInput value={value} onChange={onChange}>
+ *   {({ inputProps, isOpen, options }) => (
+ *     <div className="relative">
+ *       <input {...inputProps} className="border rounded px-2 py-1" />
+ *       {isOpen && options && (
+ *         <ul className="absolute mt-1 border rounded bg-white shadow">
+ *           {options.map((opt) => (
+ *             <li
+ *               key={opt.formatted}
+ *               className={opt.isActive ? 'bg-blue-100' : ''}
+ *               {...opt.getProps()}
+ *             >
+ *               {opt.formatted}
+ *             </li>
+ *           ))}
+ *         </ul>
+ *       )}
+ *     </div>
+ *   )}
+ * </LicensePlateInput>
+ * ```
+ */
+declare function LicensePlateInput({ value, onChange, onBlur, children, }: LicensePlateInputProps): ReactNode;
+
+export { type InputProps, LicensePlateInput, type LicensePlateInputProps, type OptionItem, type OptionProps, ParseResult, ParsedPlate, type RenderProps, type UseLicensePlateOptions, type UseLicensePlateReturn, useLicensePlate };

package/dist/react/index.js

@@ -0,0 +1,171 @@
+import {
+  LOCATION,
+  LOCATION_SET,
+  cleanPlateNo,
+  formatParsedPlate,
+  formatPlateNo,
+  isValidLicensePlate,
+  isValidLicensePlateFormat,
+  parseLicensePlate,
+  sanitizeLicensePlate
+} from "../chunk-WNVAHMV3.js";
+
+// src/react/useLicensePlate.ts
+import { useCallback, useEffect, useRef, useState } from "react";
+function useLicensePlate(options = {}) {
+  const { value = "", onChange, onBlur } = options;
+  const [inputValue, setInputValue] = useState(value);
+  const [parseResult, setParseResult] = useState(
+    () => parseLicensePlate(value)
+  );
+  const [disambiguationOptions, setDisambiguationOptions] = useState(null);
+  const [activeIndex, setActiveIndex] = useState(0);
+  const [dropdownOpen, setDropdownOpen] = useState(false);
+  const isUserTyping = useRef(false);
+  useEffect(() => {
+    if (isUserTyping.current) {
+      return;
+    }
+    if (value !== inputValue) {
+      setInputValue(value);
+      setParseResult(parseLicensePlate(value));
+    }
+  }, [value]);
+  const handleChange = useCallback(
+    (e) => {
+      const newValue = e.target.value.toUpperCase();
+      isUserTyping.current = true;
+      setInputValue(newValue);
+      const result = parseLicensePlate(newValue);
+      setParseResult(result);
+      setActiveIndex(0);
+      if (result.type === "unambiguous") {
+        const formatted = formatParsedPlate(result.plate);
+        setInputValue(formatted);
+        setDisambiguationOptions(null);
+        setDropdownOpen(false);
+        isUserTyping.current = false;
+        onChange?.(formatted);
+      } else if (result.type === "ambiguous") {
+        setDisambiguationOptions(result.options);
+        setDropdownOpen(true);
+        onChange?.(newValue);
+      } else {
+        setDisambiguationOptions(null);
+        setDropdownOpen(false);
+        onChange?.(newValue);
+      }
+    },
+    [onChange]
+  );
+  const selectOption = useCallback(
+    (option) => {
+      const formatted = formatParsedPlate(option);
+      setInputValue(formatted);
+      setParseResult({ type: "unambiguous", plate: option });
+      setDisambiguationOptions(null);
+      setDropdownOpen(false);
+      isUserTyping.current = false;
+      onChange?.(formatted);
+    },
+    [onChange]
+  );
+  const handleKeyDown = useCallback(
+    (e) => {
+      if (!disambiguationOptions || !dropdownOpen) return;
+      if (e.key === "ArrowDown") {
+        e.preventDefault();
+        setActiveIndex(
+          (prev) => Math.min(prev + 1, disambiguationOptions.length - 1)
+        );
+      } else if (e.key === "ArrowUp") {
+        e.preventDefault();
+        setActiveIndex((prev) => Math.max(prev - 1, 0));
+      } else if (e.key === "Enter") {
+        e.preventDefault();
+        const selected = disambiguationOptions[activeIndex];
+        if (selected) {
+          selectOption(selected);
+        }
+      } else if (e.key === "Escape") {
+        setDropdownOpen(false);
+      }
+    },
+    [disambiguationOptions, dropdownOpen, activeIndex, selectOption]
+  );
+  const handleBlur = useCallback(() => {
+    setTimeout(() => {
+      setDropdownOpen(false);
+      isUserTyping.current = false;
+      onBlur?.();
+    }, 150);
+  }, [onBlur]);
+  return {
+    inputValue,
+    parseResult,
+    handleChange,
+    handleKeyDown,
+    handleBlur,
+    isDropdownOpen: dropdownOpen,
+    options: disambiguationOptions,
+    activeIndex,
+    selectOption,
+    setActiveIndex
+  };
+}
+
+// src/react/LicensePlateInput.tsx
+function LicensePlateInput({
+  value,
+  onChange,
+  onBlur,
+  children
+}) {
+  const {
+    inputValue,
+    parseResult,
+    handleChange,
+    handleKeyDown,
+    handleBlur,
+    isDropdownOpen,
+    options: rawOptions,
+    activeIndex,
+    selectOption,
+    setActiveIndex
+  } = useLicensePlate({ value, onChange, onBlur });
+  const inputProps = {
+    value: inputValue,
+    onChange: handleChange,
+    onKeyDown: handleKeyDown,
+    onBlur: handleBlur
+  };
+  const options = rawOptions ? rawOptions.map((plate, index) => ({
+    plate,
+    formatted: formatParsedPlate(plate),
+    isActive: index === activeIndex,
+    getProps: () => ({
+      onClick: () => selectOption(plate),
+      onMouseDown: (e) => e.preventDefault(),
+      onMouseEnter: () => setActiveIndex(index)
+    })
+  })) : null;
+  return children({
+    inputProps,
+    isOpen: isDropdownOpen,
+    options,
+    parseResult
+  });
+}
+export {
+  LOCATION,
+  LOCATION_SET,
+  LicensePlateInput,
+  cleanPlateNo,
+  formatParsedPlate,
+  formatPlateNo,
+  isValidLicensePlate,
+  isValidLicensePlateFormat,
+  parseLicensePlate,
+  sanitizeLicensePlate,
+  useLicensePlate
+};

package/package.json

@@ -0,0 +1,63 @@
+{
+  "name": "kennzeichen",
+  "version": "0.1.0",
+  "description": "German license plate parsing and validation",
+  "type": "module",
+  "sideEffects": false,
+  "exports": {
+    ".": {
+      "import": "./dist/core/index.js",
+      "types": "./dist/core/index.d.ts"
+    },
+    "./core": {
+      "import": "./dist/core/index.js",
+      "types": "./dist/core/index.d.ts"
+    },
+    "./react": {
+      "import": "./dist/react/index.js",
+      "types": "./dist/react/index.d.ts"
+    }
+  },
+  "files": [
+    "dist"
+  ],
+  "scripts": {
+    "build": "tsup",
+    "test": "vitest run",
+    "lint": "oxlint -D recommended --ignore-pattern node_modules",
+    "typecheck": "tsc --noEmit"
+  },
+  "peerDependencies": {
+    "react": ">=17.0.0"
+  },
+  "peerDependenciesMeta": {
+    "react": {
+      "optional": true
+    }
+  },
+  "devDependencies": {
+    "@types/react": "^18.0.0",
+    "oxlint": "^0.16.0",
+    "react": "^18.0.0",
+    "tsup": "^8.0.0",
+    "typescript": "^5.0.0",
+    "vitest": "^2.0.0"
+  },
+  "keywords": [
+    "german",
+    "license-plate",
+    "kennzeichen",
+    "parser",
+    "validation"
+  ],
+  "license": "MIT",
+  "author": "Canida Software <bui.qd@canida.io>",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/canida-software/kennzeichen.git"
+  },
+  "homepage": "https://github.com/canida-software/kennzeichen#readme",
+  "bugs": {
+    "url": "https://github.com/canida-software/kennzeichen/issues"
+  }
+}