@lokascript/semantic 1.2.1 → 2.0.0

package/dist/languages/pl.js

@@ -0,0 +1,1586 @@
+// src/registry.ts
+var tokenizers = /* @__PURE__ */ new Map();
+var profiles = /* @__PURE__ */ new Map();
+var patternCache = /* @__PURE__ */ new Map();
+function registerLanguage(code, tokenizer, profile) {
+  tokenizers.set(code, tokenizer);
+  profiles.set(code, profile);
+  patternCache.delete(code);
+}
+
+// src/tokenizers/token-utils.ts
+var TokenStreamImpl = class {
+  constructor(tokens, language) {
+    this.pos = 0;
+    this.tokens = tokens;
+    this.language = language;
+  }
+  peek(offset = 0) {
+    const index = this.pos + offset;
+    if (index < 0 || index >= this.tokens.length) {
+      return null;
+    }
+    return this.tokens[index];
+  }
+  advance() {
+    if (this.isAtEnd()) {
+      throw new Error("Unexpected end of token stream");
+    }
+    return this.tokens[this.pos++];
+  }
+  isAtEnd() {
+    return this.pos >= this.tokens.length;
+  }
+  mark() {
+    return { position: this.pos };
+  }
+  reset(mark) {
+    this.pos = mark.position;
+  }
+  position() {
+    return this.pos;
+  }
+  /**
+   * Get remaining tokens as an array.
+   */
+  remaining() {
+    return this.tokens.slice(this.pos);
+  }
+  /**
+   * Consume tokens while predicate is true.
+   */
+  takeWhile(predicate) {
+    const result = [];
+    while (!this.isAtEnd() && predicate(this.peek())) {
+      result.push(this.advance());
+    }
+    return result;
+  }
+  /**
+   * Skip tokens while predicate is true.
+   */
+  skipWhile(predicate) {
+    while (!this.isAtEnd() && predicate(this.peek())) {
+      this.advance();
+    }
+  }
+};
+function createPosition(start, end) {
+  return { start, end };
+}
+function createToken(value, kind, position, normalizedOrOptions) {
+  if (typeof normalizedOrOptions === "string") {
+    return { value, kind, position, normalized: normalizedOrOptions };
+  }
+  if (normalizedOrOptions) {
+    const { normalized: normalized2, stem, stemConfidence } = normalizedOrOptions;
+    return {
+      value,
+      kind,
+      position,
+      ...normalized2 !== void 0 && { normalized: normalized2 },
+      ...stem !== void 0 && { stem },
+      ...stemConfidence !== void 0 && { stemConfidence }
+    };
+  }
+  return { value, kind, position };
+}
+function isWhitespace(char) {
+  return /\s/.test(char);
+}
+function isSelectorStart(char) {
+  return char === "#" || char === "." || char === "[" || char === "@" || char === "*" || char === "<";
+}
+function isQuote(char) {
+  return char === '"' || char === "'" || char === "`" || char === "\u300C" || char === "\u300D";
+}
+function isDigit(char) {
+  return /\d/.test(char);
+}
+function isAsciiLetter(char) {
+  return /[a-zA-Z]/.test(char);
+}
+function isAsciiIdentifierChar(char) {
+  return /[a-zA-Z0-9_-]/.test(char);
+}
+
+// src/tokenizers/char-classifiers.ts
+function createLatinCharClassifiers(letterPattern) {
+  const isLetter = (char) => letterPattern.test(char);
+  const isIdentifierChar = (char) => isLetter(char) || /[0-9_-]/.test(char);
+  return { isLetter, isIdentifierChar };
+}
+
+// src/tokenizers/extractors.ts
+function extractCssSelector(input, startPos) {
+  if (startPos >= input.length) return null;
+  const char = input[startPos];
+  if (!isSelectorStart(char)) return null;
+  let pos = startPos;
+  let selector = "";
+  if (char === "#" || char === ".") {
+    selector += input[pos++];
+    while (pos < input.length && isAsciiIdentifierChar(input[pos])) {
+      selector += input[pos++];
+    }
+    if (selector.length <= 1) return null;
+    if (pos < input.length && input[pos] === "." && char === "#") {
+      const methodStart = pos + 1;
+      let methodEnd = methodStart;
+      while (methodEnd < input.length && isAsciiIdentifierChar(input[methodEnd])) {
+        methodEnd++;
+      }
+      if (methodEnd < input.length && input[methodEnd] === "(") {
+        return selector;
+      }
+    }
+  } else if (char === "[") {
+    let depth = 1;
+    let inQuote = false;
+    let quoteChar = null;
+    let escaped = false;
+    selector += input[pos++];
+    while (pos < input.length && depth > 0) {
+      const c = input[pos];
+      selector += c;
+      if (escaped) {
+        escaped = false;
+      } else if (c === "\\") {
+        escaped = true;
+      } else if (inQuote) {
+        if (c === quoteChar) {
+          inQuote = false;
+          quoteChar = null;
+        }
+      } else {
+        if (c === '"' || c === "'" || c === "`") {
+          inQuote = true;
+          quoteChar = c;
+        } else if (c === "[") {
+          depth++;
+        } else if (c === "]") {
+          depth--;
+        }
+      }
+      pos++;
+    }
+    if (depth !== 0) return null;
+  } else if (char === "@") {
+    selector += input[pos++];
+    while (pos < input.length && isAsciiIdentifierChar(input[pos])) {
+      selector += input[pos++];
+    }
+    if (selector.length <= 1) return null;
+  } else if (char === "*") {
+    selector += input[pos++];
+    while (pos < input.length && isAsciiIdentifierChar(input[pos])) {
+      selector += input[pos++];
+    }
+    if (selector.length <= 1) return null;
+  } else if (char === "<") {
+    selector += input[pos++];
+    if (pos >= input.length || !isAsciiLetter(input[pos])) return null;
+    while (pos < input.length && isAsciiIdentifierChar(input[pos])) {
+      selector += input[pos++];
+    }
+    while (pos < input.length) {
+      const modChar = input[pos];
+      if (modChar === ".") {
+        selector += input[pos++];
+        if (pos >= input.length || !isAsciiIdentifierChar(input[pos])) {
+          return null;
+        }
+        while (pos < input.length && isAsciiIdentifierChar(input[pos])) {
+          selector += input[pos++];
+        }
+      } else if (modChar === "#") {
+        selector += input[pos++];
+        if (pos >= input.length || !isAsciiIdentifierChar(input[pos])) {
+          return null;
+        }
+        while (pos < input.length && isAsciiIdentifierChar(input[pos])) {
+          selector += input[pos++];
+        }
+      } else if (modChar === "[") {
+        let depth = 1;
+        let inQuote = false;
+        let quoteChar = null;
+        let escaped = false;
+        selector += input[pos++];
+        while (pos < input.length && depth > 0) {
+          const c = input[pos];
+          selector += c;
+          if (escaped) {
+            escaped = false;
+          } else if (c === "\\") {
+            escaped = true;
+          } else if (inQuote) {
+            if (c === quoteChar) {
+              inQuote = false;
+              quoteChar = null;
+            }
+          } else {
+            if (c === '"' || c === "'" || c === "`") {
+              inQuote = true;
+              quoteChar = c;
+            } else if (c === "[") {
+              depth++;
+            } else if (c === "]") {
+              depth--;
+            }
+          }
+          pos++;
+        }
+        if (depth !== 0) return null;
+      } else {
+        break;
+      }
+    }
+    while (pos < input.length && isWhitespace(input[pos])) {
+      selector += input[pos++];
+    }
+    if (pos < input.length && input[pos] === "/") {
+      selector += input[pos++];
+      while (pos < input.length && isWhitespace(input[pos])) {
+        selector += input[pos++];
+      }
+    }
+    if (pos >= input.length || input[pos] !== ">") return null;
+    selector += input[pos++];
+  }
+  return selector || null;
+}
+function isPossessiveMarker(input, pos) {
+  if (pos >= input.length || input[pos] !== "'") return false;
+  if (pos + 1 >= input.length) return false;
+  const nextChar = input[pos + 1].toLowerCase();
+  if (nextChar !== "s") return false;
+  if (pos + 2 >= input.length) return true;
+  const afterS = input[pos + 2];
+  return isWhitespace(afterS) || afterS === "*" || !isAsciiIdentifierChar(afterS);
+}
+function extractStringLiteral(input, startPos) {
+  if (startPos >= input.length) return null;
+  const openQuote = input[startPos];
+  if (!isQuote(openQuote)) return null;
+  if (openQuote === "'" && isPossessiveMarker(input, startPos)) {
+    return null;
+  }
+  const closeQuoteMap = {
+    '"': '"',
+    "'": "'",
+    "`": "`",
+    "\u300C": "\u300D"
+  };
+  const closeQuote = closeQuoteMap[openQuote];
+  if (!closeQuote) return null;
+  let pos = startPos + 1;
+  let literal = openQuote;
+  let escaped = false;
+  while (pos < input.length) {
+    const char = input[pos];
+    literal += char;
+    if (escaped) {
+      escaped = false;
+    } else if (char === "\\") {
+      escaped = true;
+    } else if (char === closeQuote) {
+      return literal;
+    }
+    pos++;
+  }
+  return literal;
+}
+function isUrlStart(input, pos) {
+  if (pos >= input.length) return false;
+  const char = input[pos];
+  const next = input[pos + 1] || "";
+  const third = input[pos + 2] || "";
+  if (char === "/" && next !== "/" && /[a-zA-Z0-9._-]/.test(next)) {
+    return true;
+  }
+  if (char === "/" && next === "/" && /[a-zA-Z]/.test(third)) {
+    return true;
+  }
+  if (char === "." && (next === "/" || next === "." && third === "/")) {
+    return true;
+  }
+  const slice = input.slice(pos, pos + 8).toLowerCase();
+  if (slice.startsWith("http://") || slice.startsWith("https://")) {
+    return true;
+  }
+  return false;
+}
+function extractUrl(input, startPos) {
+  if (!isUrlStart(input, startPos)) return null;
+  let pos = startPos;
+  let url = "";
+  const urlChars = /[a-zA-Z0-9/:._\-?&=%@+~!$'()*,;[\]]/;
+  while (pos < input.length) {
+    const char = input[pos];
+    if (char === "#") {
+      if (url.length > 0 && /[a-zA-Z0-9/.]$/.test(url)) {
+        url += char;
+        pos++;
+        while (pos < input.length && /[a-zA-Z0-9_-]/.test(input[pos])) {
+          url += input[pos++];
+        }
+      }
+      break;
+    }
+    if (urlChars.test(char)) {
+      url += char;
+      pos++;
+    } else {
+      break;
+    }
+  }
+  if (url.length < 2) return null;
+  return url;
+}
+function extractNumber(input, startPos) {
+  if (startPos >= input.length) return null;
+  const char = input[startPos];
+  if (!isDigit(char) && char !== "-" && char !== "+") return null;
+  let pos = startPos;
+  let number = "";
+  if (input[pos] === "-" || input[pos] === "+") {
+    number += input[pos++];
+  }
+  if (pos >= input.length || !isDigit(input[pos])) {
+    return null;
+  }
+  while (pos < input.length && isDigit(input[pos])) {
+    number += input[pos++];
+  }
+  if (pos < input.length && input[pos] === ".") {
+    number += input[pos++];
+    while (pos < input.length && isDigit(input[pos])) {
+      number += input[pos++];
+    }
+  }
+  if (pos < input.length) {
+    const suffix = input.slice(pos, pos + 2);
+    if (suffix === "ms") {
+      number += "ms";
+    } else if (input[pos] === "s" || input[pos] === "m" || input[pos] === "h") {
+      number += input[pos];
+    }
+  }
+  return number;
+}
+
+// src/tokenizers/base-tokenizer.ts
+var _BaseTokenizer = class _BaseTokenizer {
+  constructor() {
+    /** Keywords derived from profile, sorted longest-first for greedy matching */
+    this.profileKeywords = [];
+    /** Map for O(1) keyword lookups by lowercase native word */
+    this.profileKeywordMap = /* @__PURE__ */ new Map();
+  }
+  /**
+   * Check if current position is a property access (obj.prop) vs CSS selector (.active).
+   * Property access: no whitespace before '.', previous token is identifier/keyword/selector.
+   * Also detects standalone method calls: .identifier( pattern.
+   *
+   * Returns true if '.' was emitted as an operator token and pos should advance by 1.
+   * Returns false if this is a CSS selector and should be handled by trySelector().
+   */
+  tryPropertyAccess(input, pos, tokens) {
+    if (input[pos] !== ".") return false;
+    const lastToken = tokens[tokens.length - 1];
+    const hasWhitespaceBefore = lastToken && lastToken.position.end < pos;
+    const isPropertyAccess = lastToken && !hasWhitespaceBefore && (lastToken.kind === "identifier" || lastToken.kind === "keyword" || lastToken.kind === "selector");
+    if (isPropertyAccess) {
+      tokens.push(createToken(".", "operator", createPosition(pos, pos + 1)));
+      return true;
+    }
+    const methodStart = pos + 1;
+    let methodEnd = methodStart;
+    while (methodEnd < input.length && isAsciiIdentifierChar(input[methodEnd])) {
+      methodEnd++;
+    }
+    if (methodEnd < input.length && input[methodEnd] === "(") {
+      tokens.push(createToken(".", "operator", createPosition(pos, pos + 1)));
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Initialize keyword mappings from a language profile.
+   * Builds a list of native→english mappings from:
+   * - profile.keywords (primary + alternatives)
+   * - profile.references (me, it, you, etc.)
+   * - profile.roleMarkers (into, from, with, etc.)
+   *
+   * Results are sorted longest-first for greedy matching (important for non-space languages).
+   * Extras take precedence over profile entries when there are duplicates.
+   *
+   * @param profile - Language profile containing keyword translations
+   * @param extras - Additional keyword entries to include (literals, positional, events)
+   */
+  initializeKeywordsFromProfile(profile, extras = []) {
+    const keywordMap = /* @__PURE__ */ new Map();
+    if (profile.keywords) {
+      for (const [normalized2, translation] of Object.entries(profile.keywords)) {
+        keywordMap.set(translation.primary, {
+          native: translation.primary,
+          normalized: translation.normalized || normalized2
+        });
+        if (translation.alternatives) {
+          for (const alt of translation.alternatives) {
+            keywordMap.set(alt, {
+              native: alt,
+              normalized: translation.normalized || normalized2
+            });
+          }
+        }
+      }
+    }
+    if (profile.references) {
+      for (const [normalized2, native] of Object.entries(profile.references)) {
+        keywordMap.set(native, { native, normalized: normalized2 });
+      }
+      for (const canonical of Object.keys(profile.references)) {
+        if (!keywordMap.has(canonical)) {
+          keywordMap.set(canonical, { native: canonical, normalized: canonical });
+        }
+      }
+    }
+    if (profile.roleMarkers) {
+      for (const [role, marker] of Object.entries(profile.roleMarkers)) {
+        if (marker.primary) {
+          keywordMap.set(marker.primary, { native: marker.primary, normalized: role });
+        }
+        if (marker.alternatives) {
+          for (const alt of marker.alternatives) {
+            keywordMap.set(alt, { native: alt, normalized: role });
+          }
+        }
+      }
+    }
+    for (const extra of extras) {
+      keywordMap.set(extra.native, extra);
+    }
+    this.profileKeywords = Array.from(keywordMap.values()).sort(
+      (a, b) => b.native.length - a.native.length
+    );
+    this.profileKeywordMap = /* @__PURE__ */ new Map();
+    for (const keyword of this.profileKeywords) {
+      this.profileKeywordMap.set(keyword.native.toLowerCase(), keyword);
+      const normalized2 = this.removeDiacritics(keyword.native);
+      if (normalized2 !== keyword.native && !this.profileKeywordMap.has(normalized2.toLowerCase())) {
+        this.profileKeywordMap.set(normalized2.toLowerCase(), keyword);
+      }
+    }
+  }
+  /**
+   * Remove diacritical marks from a word for normalization.
+   * Primarily for Arabic (shadda, fatha, kasra, damma, sukun, etc.)
+   * but could be extended for other languages.
+   *
+   * @param word - Word to normalize
+   * @returns Word without diacritics
+   */
+  removeDiacritics(word) {
+    return word.replace(/[\u064B-\u0652\u0670]/g, "");
+  }
+  /**
+   * Try to match a keyword from profile at the current position.
+   * Uses longest-first greedy matching (important for non-space languages).
+   *
+   * @param input - Input string
+   * @param pos - Current position
+   * @returns Token if matched, null otherwise
+   */
+  tryProfileKeyword(input, pos) {
+    for (const entry of this.profileKeywords) {
+      if (input.slice(pos).startsWith(entry.native)) {
+        return createToken(
+          entry.native,
+          "keyword",
+          createPosition(pos, pos + entry.native.length),
+          entry.normalized
+        );
+      }
+    }
+    return null;
+  }
+  /**
+   * Check if the remaining input starts with any known keyword.
+   * Useful for non-space languages to detect word boundaries.
+   *
+   * @param input - Input string
+   * @param pos - Current position
+   * @returns true if a keyword starts at this position
+   */
+  isKeywordStart(input, pos) {
+    const remaining = input.slice(pos);
+    return this.profileKeywords.some((entry) => remaining.startsWith(entry.native));
+  }
+  /**
+   * Look up a keyword by native word (case-insensitive).
+   * O(1) lookup using the keyword map.
+   *
+   * @param native - Native word to look up
+   * @returns KeywordEntry if found, undefined otherwise
+   */
+  lookupKeyword(native) {
+    return this.profileKeywordMap.get(native.toLowerCase());
+  }
+  /**
+   * Check if a word is a known keyword (case-insensitive).
+   * O(1) lookup using the keyword map.
+   *
+   * @param native - Native word to check
+   * @returns true if the word is a keyword
+   */
+  isKeyword(native) {
+    return this.profileKeywordMap.has(native.toLowerCase());
+  }
+  /**
+   * Set the morphological normalizer for this tokenizer.
+   */
+  setNormalizer(normalizer) {
+    this.normalizer = normalizer;
+  }
+  /**
+   * Try to normalize a word using the morphological normalizer.
+   * Returns null if no normalizer is set or normalization fails.
+   *
+   * Note: We don't check isNormalizable() here because the individual tokenizers
+   * historically called normalize() directly without that check. The normalize()
+   * method itself handles returning noChange() for words that can't be normalized.
+   */
+  tryNormalize(word) {
+    if (!this.normalizer) return null;
+    const result = this.normalizer.normalize(word);
+    if (result.stem !== word && result.confidence >= 0.7) {
+      return result;
+    }
+    return null;
+  }
+  /**
+   * Try morphological normalization and keyword lookup.
+   *
+   * If the word can be normalized to a stem that matches a known keyword,
+   * returns a keyword token with morphological metadata (stem, stemConfidence).
+   *
+   * This is the common pattern for handling conjugated verbs across languages:
+   * 1. Normalize the word (e.g., "toggled" → "toggle")
+   * 2. Look up the stem in the keyword map
+   * 3. Create a token with both the original form and stem metadata
+   *
+   * @param word - The word to normalize and look up
+   * @param startPos - Start position for the token
+   * @param endPos - End position for the token
+   * @returns Token if stem matches a keyword, null otherwise
+   */
+  tryMorphKeywordMatch(word, startPos, endPos) {
+    const result = this.tryNormalize(word);
+    if (!result) return null;
+    const stemEntry = this.lookupKeyword(result.stem);
+    if (!stemEntry) return null;
+    const tokenOptions = {
+      normalized: stemEntry.normalized,
+      stem: result.stem,
+      stemConfidence: result.confidence
+    };
+    return createToken(word, "keyword", createPosition(startPos, endPos), tokenOptions);
+  }
+  /**
+   * Try to extract a CSS selector at the current position.
+   */
+  trySelector(input, pos) {
+    const selector = extractCssSelector(input, pos);
+    if (selector) {
+      return createToken(selector, "selector", createPosition(pos, pos + selector.length));
+    }
+    return null;
+  }
+  /**
+   * Try to extract an event modifier at the current position.
+   * Event modifiers are .once, .debounce(N), .throttle(N), .queue(strategy)
+   */
+  tryEventModifier(input, pos) {
+    if (input[pos] !== ".") {
+      return null;
+    }
+    const match = input.slice(pos).match(/^\.(?:once|debounce|throttle|queue)(?:\(([^)]+)\))?(?:\s|$|\.)/);
+    if (!match) {
+      return null;
+    }
+    const fullMatch = match[0].replace(/(\s|\.)$/, "");
+    const modifierName = fullMatch.slice(1).split("(")[0];
+    const value = match[1];
+    const token = createToken(
+      fullMatch,
+      "event-modifier",
+      createPosition(pos, pos + fullMatch.length)
+    );
+    return {
+      ...token,
+      metadata: {
+        modifierName,
+        value: value ? modifierName === "queue" ? value : parseInt(value, 10) : void 0
+      }
+    };
+  }
+  /**
+   * Try to extract a string literal at the current position.
+   */
+  tryString(input, pos) {
+    const literal = extractStringLiteral(input, pos);
+    if (literal) {
+      return createToken(literal, "literal", createPosition(pos, pos + literal.length));
+    }
+    return null;
+  }
+  /**
+   * Try to extract a number at the current position.
+   */
+  tryNumber(input, pos) {
+    const number = extractNumber(input, pos);
+    if (number) {
+      return createToken(number, "literal", createPosition(pos, pos + number.length));
+    }
+    return null;
+  }
+  /**
+   * Try to match a time unit from a list of patterns.
+   *
+   * @param input - Input string
+   * @param pos - Position after the number
+   * @param timeUnits - Array of time unit mappings (native pattern → standard suffix)
+   * @param skipWhitespace - Whether to skip whitespace before time unit (default: false)
+   * @returns Object with matched suffix and new position, or null if no match
+   */
+  tryMatchTimeUnit(input, pos, timeUnits, skipWhitespace = false) {
+    let unitPos = pos;
+    if (skipWhitespace) {
+      while (unitPos < input.length && isWhitespace(input[unitPos])) {
+        unitPos++;
+      }
+    }
+    const remaining = input.slice(unitPos);
+    for (const unit of timeUnits) {
+      const candidate = remaining.slice(0, unit.length);
+      const matches = unit.caseInsensitive ? candidate.toLowerCase() === unit.pattern.toLowerCase() : candidate === unit.pattern;
+      if (matches) {
+        if (unit.notFollowedBy) {
+          const nextChar = remaining[unit.length] || "";
+          if (nextChar === unit.notFollowedBy) continue;
+        }
+        if (unit.checkBoundary) {
+          const nextChar = remaining[unit.length] || "";
+          if (isAsciiIdentifierChar(nextChar)) continue;
+        }
+        return { suffix: unit.suffix, endPos: unitPos + unit.length };
+      }
+    }
+    return null;
+  }
+  /**
+   * Parse a base number (sign, integer, decimal) without time units.
+   * Returns the number string and end position.
+   *
+   * @param input - Input string
+   * @param startPos - Start position
+   * @param allowSign - Whether to allow +/- sign (default: true)
+   * @returns Object with number string and end position, or null
+   */
+  parseBaseNumber(input, startPos, allowSign = true) {
+    let pos = startPos;
+    let number = "";
+    if (allowSign && (input[pos] === "-" || input[pos] === "+")) {
+      number += input[pos++];
+    }
+    if (pos >= input.length || !isDigit(input[pos])) {
+      return null;
+    }
+    while (pos < input.length && isDigit(input[pos])) {
+      number += input[pos++];
+    }
+    if (pos < input.length && input[pos] === ".") {
+      number += input[pos++];
+      while (pos < input.length && isDigit(input[pos])) {
+        number += input[pos++];
+      }
+    }
+    if (!number || number === "-" || number === "+") return null;
+    return { number, endPos: pos };
+  }
+  /**
+   * Try to extract a number with native language time units.
+   *
+   * This is a template method that handles the common pattern:
+   * 1. Parse the base number (sign, integer, decimal)
+   * 2. Try to match native language time units
+   * 3. Fall back to standard time units (ms, s, m, h)
+   *
+   * @param input - Input string
+   * @param pos - Start position
+   * @param nativeTimeUnits - Language-specific time unit mappings
+   * @param options - Configuration options
+   * @returns Token if number found, null otherwise
+   */
+  tryNumberWithTimeUnits(input, pos, nativeTimeUnits, options = {}) {
+    const { allowSign = true, skipWhitespace = false } = options;
+    const baseResult = this.parseBaseNumber(input, pos, allowSign);
+    if (!baseResult) return null;
+    let { number, endPos } = baseResult;
+    const allUnits = [...nativeTimeUnits, ..._BaseTokenizer.STANDARD_TIME_UNITS];
+    const timeMatch = this.tryMatchTimeUnit(input, endPos, allUnits, skipWhitespace);
+    if (timeMatch) {
+      number += timeMatch.suffix;
+      endPos = timeMatch.endPos;
+    }
+    return createToken(number, "literal", createPosition(pos, endPos));
+  }
+  /**
+   * Try to extract a URL at the current position.
+   * Handles /path, ./path, ../path, //domain.com, http://, https://
+   */
+  tryUrl(input, pos) {
+    const url = extractUrl(input, pos);
+    if (url) {
+      return createToken(url, "url", createPosition(pos, pos + url.length));
+    }
+    return null;
+  }
+  /**
+   * Try to extract a variable reference (:varname) at the current position.
+   * In hyperscript, :x refers to a local variable named x.
+   */
+  tryVariableRef(input, pos) {
+    if (input[pos] !== ":") return null;
+    if (pos + 1 >= input.length) return null;
+    if (!isAsciiIdentifierChar(input[pos + 1])) return null;
+    let endPos = pos + 1;
+    while (endPos < input.length && isAsciiIdentifierChar(input[endPos])) {
+      endPos++;
+    }
+    const varRef = input.slice(pos, endPos);
+    return createToken(varRef, "identifier", createPosition(pos, endPos));
+  }
+  /**
+   * Try to extract an operator or punctuation token at the current position.
+   * Handles two-character operators (==, !=, etc.) and single-character operators.
+   */
+  tryOperator(input, pos) {
+    const twoChar = input.slice(pos, pos + 2);
+    if (["==", "!=", "<=", ">=", "&&", "||", "->"].includes(twoChar)) {
+      return createToken(twoChar, "operator", createPosition(pos, pos + 2));
+    }
+    const oneChar = input[pos];
+    if (["<", ">", "!", "+", "-", "*", "/", "="].includes(oneChar)) {
+      return createToken(oneChar, "operator", createPosition(pos, pos + 1));
+    }
+    if (["(", ")", "{", "}", ",", ";", ":"].includes(oneChar)) {
+      return createToken(oneChar, "punctuation", createPosition(pos, pos + 1));
+    }
+    return null;
+  }
+  /**
+   * Try to match a multi-character particle from a list.
+   *
+   * Used by languages like Japanese, Korean, and Chinese that have
+   * multi-character particles (e.g., Japanese から, まで, より).
+   *
+   * @param input - Input string
+   * @param pos - Current position
+   * @param particles - Array of multi-character particles to match
+   * @returns Token if matched, null otherwise
+   */
+  tryMultiCharParticle(input, pos, particles) {
+    for (const particle of particles) {
+      if (input.slice(pos, pos + particle.length) === particle) {
+        return createToken(particle, "particle", createPosition(pos, pos + particle.length));
+      }
+    }
+    return null;
+  }
+};
+/**
+ * Configuration for native language time units.
+ * Maps patterns to their standard suffix (ms, s, m, h).
+ */
+_BaseTokenizer.STANDARD_TIME_UNITS = [
+  { pattern: "ms", suffix: "ms", length: 2 },
+  { pattern: "s", suffix: "s", length: 1, checkBoundary: true },
+  { pattern: "m", suffix: "m", length: 1, checkBoundary: true, notFollowedBy: "s" },
+  { pattern: "h", suffix: "h", length: 1, checkBoundary: true }
+];
+var BaseTokenizer = _BaseTokenizer;
+
+// src/generators/profiles/polish.ts
+var polishProfile = {
+  code: "pl",
+  name: "Polish",
+  nativeName: "Polski",
+  direction: "ltr",
+  wordOrder: "SVO",
+  markingStrategy: "preposition",
+  usesSpaces: true,
+  // Polish uses imperative form for commands in software UI
+  // (unlike most languages that use infinitive)
+  defaultVerbForm: "imperative",
+  verb: {
+    position: "start",
+    subjectDrop: true,
+    suffixes: ["a\u0107", "e\u0107", "i\u0107", "y\u0107", "\u0105\u0107", "owa\u0107"]
+  },
+  references: {
+    me: "ja",
+    // "I/me"
+    it: "to",
+    // "it"
+    you: "ty",
+    // "you"
+    result: "wynik",
+    event: "zdarzenie",
+    target: "cel",
+    body: "body"
+  },
+  possessive: {
+    marker: "",
+    // Polish uses genitive case, not a marker
+    markerPosition: "after-object",
+    usePossessiveAdjectives: true,
+    specialForms: {
+      me: "m\xF3j",
+      // "my" (masculine)
+      it: "jego",
+      // "its"
+      you: "tw\xF3j"
+      // "your"
+    },
+    keywords: {
+      // "my" variants (masculine/feminine/neuter)
+      m\u00F3j: "me",
+      moja: "me",
+      moje: "me",
+      // "your" variants
+      tw\u00F3j: "you",
+      twoja: "you",
+      twoje: "you",
+      // "its/his/her" forms
+      jego: "it",
+      // his/its
+      jej: "it"
+      // her/its (feminine)
+    }
+  },
+  roleMarkers: {
+    destination: { primary: "do", alternatives: ["w", "na"], position: "before" },
+    source: { primary: "z", alternatives: ["od", "ze"], position: "before" },
+    patient: { primary: "", position: "before" },
+    style: { primary: "z", alternatives: ["ze"], position: "before" }
+  },
+  keywords: {
+    // Class/Attribute operations (imperative form)
+    toggle: {
+      primary: "prze\u0142\u0105cz",
+      alternatives: ["przelacz"],
+      normalized: "toggle",
+      form: "imperative"
+    },
+    add: { primary: "dodaj", normalized: "add", form: "imperative" },
+    remove: {
+      primary: "usu\u0144",
+      alternatives: ["usun", "wyczy\u015B\u0107", "wyczysc"],
+      normalized: "remove",
+      form: "imperative"
+    },
+    // Content operations
+    put: {
+      primary: "umie\u015B\u0107",
+      alternatives: ["umiesc", "wstaw"],
+      normalized: "put",
+      form: "imperative"
+    },
+    append: {
+      primary: "do\u0142\u0105cz",
+      alternatives: ["dolacz"],
+      normalized: "append",
+      form: "imperative"
+    },
+    prepend: {
+      primary: "poprzed\u017A",
+      alternatives: ["poprzedz"],
+      normalized: "prepend",
+      form: "imperative"
+    },
+    take: {
+      primary: "we\u017A",
+      alternatives: ["wez"],
+      // removed 'pobierz' - it's the primary keyword for 'get'
+      normalized: "take",
+      form: "imperative"
+    },
+    make: {
+      primary: "utw\xF3rz",
+      alternatives: ["utworz", "stw\xF3rz", "stworz"],
+      normalized: "make",
+      form: "imperative"
+    },
+    clone: {
+      primary: "sklonuj",
+      alternatives: ["kopiuj"],
+      normalized: "clone",
+      form: "imperative"
+    },
+    swap: { primary: "zamie\u0144", alternatives: ["zamien"], normalized: "swap", form: "imperative" },
+    morph: {
+      primary: "przekszta\u0142\u0107",
+      alternatives: ["przeksztalc"],
+      normalized: "morph",
+      form: "imperative"
+    },
+    // Variable operations
+    set: {
+      primary: "ustaw",
+      alternatives: ["okre\u015Bl", "okresl"],
+      normalized: "set",
+      form: "imperative"
+    },
+    get: {
+      primary: "pobierz",
+      alternatives: ["we\u017A", "wez"],
+      normalized: "get",
+      form: "imperative"
+    },
+    increment: {
+      primary: "zwi\u0119ksz",
+      alternatives: ["zwieksz"],
+      normalized: "increment",
+      form: "imperative"
+    },
+    decrement: { primary: "zmniejsz", normalized: "decrement", form: "imperative" },
+    log: { primary: "loguj", alternatives: ["wypisz"], normalized: "log", form: "imperative" },
+    // Visibility
+    show: {
+      primary: "poka\u017C",
+      alternatives: ["pokaz", "wy\u015Bwietl", "wyswietl"],
+      normalized: "show",
+      form: "imperative"
+    },
+    hide: { primary: "ukryj", alternatives: ["schowaj"], normalized: "hide", form: "imperative" },
+    transition: {
+      primary: "animuj",
+      alternatives: ["przej\u015Bcie", "przejscie"],
+      normalized: "transition",
+      form: "imperative"
+    },
+    // Events
+    on: { primary: "gdy", alternatives: ["kiedy", "przy", "na"], normalized: "on" },
+    trigger: {
+      primary: "wywo\u0142aj",
+      alternatives: ["wywolaj", "wyzw\xF3l", "wyzwol"],
+      normalized: "trigger",
+      form: "imperative"
+    },
+    send: { primary: "wy\u015Blij", alternatives: ["wyslij"], normalized: "send", form: "imperative" },
+    // DOM focus
+    focus: {
+      primary: "skup",
+      alternatives: ["skupienie"],
+      normalized: "focus",
+      form: "imperative"
+    },
+    blur: { primary: "rozmyj", alternatives: ["odskup"], normalized: "blur", form: "imperative" },
+    // Navigation
+    go: {
+      primary: "id\u017A",
+      alternatives: ["idz", "przejd\u017A", "przejdz", "nawiguj"],
+      normalized: "go",
+      form: "imperative"
+    },
+    // Async
+    wait: { primary: "czekaj", alternatives: ["poczekaj"], normalized: "wait", form: "imperative" },
+    fetch: {
+      primary: "pobierz",
+      alternatives: ["za\u0142aduj", "zaladuj"],
+      normalized: "fetch",
+      form: "imperative"
+    },
+    settle: { primary: "ustabilizuj", normalized: "settle", form: "imperative" },
+    // Control flow
+    if: { primary: "je\u015Bli", alternatives: ["jesli", "je\u017Celi", "jezeli"], normalized: "if" },
+    when: { primary: "kiedy", normalized: "when" },
+    where: { primary: "gdzie", normalized: "where" },
+    else: { primary: "inaczej", alternatives: ["wpp"], normalized: "else" },
+    repeat: {
+      primary: "powt\xF3rz",
+      alternatives: ["powtorz"],
+      normalized: "repeat",
+      form: "imperative"
+    },
+    for: { primary: "dla", alternatives: ["ka\u017Cdy", "kazdy"], normalized: "for" },
+    while: { primary: "dop\xF3ki", alternatives: ["dopoki", "podczas"], normalized: "while" },
+    continue: {
+      primary: "kontynuuj",
+      alternatives: ["dalej"],
+      normalized: "continue",
+      form: "imperative"
+    },
+    halt: {
+      primary: "zatrzymaj",
+      alternatives: ["przerwij", "stop"],
+      normalized: "halt",
+      form: "imperative"
+    },
+    throw: { primary: "rzu\u0107", alternatives: ["rzuc"], normalized: "throw", form: "imperative" },
+    call: { primary: "wywo\u0142aj", alternatives: ["wywolaj"], normalized: "call", form: "imperative" },
+    return: { primary: "zwr\xF3\u0107", alternatives: ["zwroc"], normalized: "return", form: "imperative" },
+    then: {
+      primary: "wtedy",
+      alternatives: ["potem", "nast\u0119pnie", "nastepnie"],
+      normalized: "then"
+    },
+    and: { primary: "i", alternatives: ["oraz"], normalized: "and" },
+    end: { primary: "koniec", normalized: "end" },
+    // Advanced
+    js: { primary: "js", normalized: "js" },
+    async: { primary: "async", alternatives: ["asynchronicznie"], normalized: "async" },
+    tell: { primary: "powiedz", normalized: "tell", form: "imperative" },
+    default: { primary: "domy\u015Blnie", alternatives: ["domyslnie"], normalized: "default" },
+    init: { primary: "inicjuj", normalized: "init", form: "imperative" },
+    behavior: { primary: "zachowanie", normalized: "behavior" },
+    install: { primary: "zainstaluj", normalized: "install", form: "imperative" },
+    measure: { primary: "zmierz", normalized: "measure", form: "imperative" },
+    beep: { primary: "sygna\u0142", normalized: "beep" },
+    break: { primary: "przerwij", normalized: "break" },
+    copy: { primary: "kopiuj", normalized: "copy" },
+    exit: { primary: "wyjd\u017A", normalized: "exit" },
+    pick: { primary: "wybierz", normalized: "pick" },
+    render: { primary: "renderuj", normalized: "render" },
+    // Modifiers
+    into: { primary: "do", alternatives: ["w"], normalized: "into" },
+    before: { primary: "przed", normalized: "before" },
+    after: { primary: "po", normalized: "after" },
+    // Common event names (for event handler patterns)
+    click: { primary: "klikni\u0119ciu", alternatives: ["klikniecie", "klik"], normalized: "click" },
+    hover: { primary: "najechaniu", alternatives: ["hover"], normalized: "hover" },
+    submit: { primary: "wys\u0142aniu", alternatives: ["wyslaniu", "submit"], normalized: "submit" },
+    input: { primary: "wprowadzeniu", alternatives: ["input"], normalized: "input" },
+    change: { primary: "zmianie", alternatives: ["zmiana"], normalized: "change" },
+    // Event modifiers
+    until: { primary: "a\u017C", alternatives: ["az", "do"], normalized: "until" },
+    event: { primary: "zdarzenie", normalized: "event" },
+    from: { primary: "z", alternatives: ["od", "ze"], normalized: "from" }
+  },
+  eventHandler: {
+    keyword: { primary: "gdy", alternatives: ["kiedy", "przy", "na"], normalized: "on" },
+    sourceMarker: { primary: "na", alternatives: ["w", "przy"], position: "before" },
+    conditionalKeyword: { primary: "kiedy", alternatives: ["gdy", "je\u015Bli"] },
+    // Event marker: przy (at/on), used in SVO pattern
+    // Pattern: przy [event] [verb] [patient] na [destination?]
+    // Example: przy kliknięciu przełącz .active na #button
+    eventMarker: { primary: "przy", alternatives: ["na"], position: "before" },
+    temporalMarkers: ["kiedy", "gdy", "przy"]
+    // temporal conjunctions (when, at)
+  }
+};
+
+// src/tokenizers/morphology/types.ts
+function noChange(word) {
+  return { stem: word, confidence: 1 };
+}
+function normalized(stem, confidence, metadata) {
+  if (metadata) {
+    return { stem, confidence, metadata };
+  }
+  return { stem, confidence };
+}
+
+// src/tokenizers/morphology/polish-normalizer.ts
+var IMPERATIVE_TO_INFINITIVE = /* @__PURE__ */ new Map([
+  // Core commands
+  ["prze\u0142\u0105cz", "prze\u0142\u0105cza\u0107"],
+  ["przelacz", "przelaczac"],
+  ["dodaj", "dodawa\u0107"],
+  ["usu\u0144", "usuwa\u0107"],
+  ["usun", "usuwac"],
+  ["umie\u015B\u0107", "umieszcza\u0107"],
+  ["umiesc", "umieszczac"],
+  ["wstaw", "wstawia\u0107"],
+  ["ustaw", "ustawia\u0107"],
+  ["pobierz", "pobiera\u0107"],
+  ["we\u017A", "bra\u0107"],
+  ["wez", "brac"],
+  ["zwi\u0119ksz", "zwi\u0119ksza\u0107"],
+  ["zwieksz", "zwiekszac"],
+  ["zmniejsz", "zmniejsza\u0107"],
+  ["poka\u017C", "pokazywa\u0107"],
+  ["pokaz", "pokazywac"],
+  ["ukryj", "ukrywa\u0107"],
+  ["schowaj", "schowywa\u0107"],
+  ["czekaj", "czeka\u0107"],
+  ["poczekaj", "poczeka\u0107"],
+  ["id\u017A", "i\u015B\u0107"],
+  ["idz", "isc"],
+  ["przejd\u017A", "przej\u015B\u0107"],
+  ["przejdz", "przejsc"],
+  ["wywo\u0142aj", "wywo\u0142ywa\u0107"],
+  ["wywolaj", "wywolywac"],
+  ["wy\u015Blij", "wysy\u0142a\u0107"],
+  ["wyslij", "wysylac"],
+  ["loguj", "logowa\u0107"],
+  ["wypisz", "wypisywa\u0107"],
+  ["sklonuj", "sklonowa\u0107"],
+  ["kopiuj", "kopiowa\u0107"],
+  ["zamie\u0144", "zamienia\u0107"],
+  ["zamien", "zamieniac"],
+  ["utw\xF3rz", "tworzy\u0107"],
+  ["utworz", "tworzyc"],
+  ["stw\xF3rz", "stwarza\u0107"],
+  ["stworz", "stwarzac"],
+  ["skup", "skupia\u0107"],
+  ["rozmyj", "rozmywa\u0107"],
+  ["nawiguj", "nawigowa\u0107"],
+  ["za\u0142aduj", "\u0142adowa\u0107"],
+  ["zaladuj", "ladowac"],
+  ["powt\xF3rz", "powtarza\u0107"],
+  ["powtorz", "powtarzac"],
+  ["kontynuuj", "kontynuowa\u0107"],
+  ["zatrzymaj", "zatrzymywa\u0107"],
+  ["przerwij", "przerywa\u0107"],
+  ["rzu\u0107", "rzuca\u0107"],
+  ["rzuc", "rzucac"],
+  ["zwr\xF3\u0107", "zwraca\u0107"],
+  ["zwroc", "zwracac"],
+  ["inicjuj", "inicjowa\u0107"],
+  ["zainstaluj", "instalowa\u0107"],
+  ["zmierz", "mierzy\u0107"]
+]);
+var PolishMorphologicalNormalizer = class {
+  constructor() {
+    this.language = "pl";
+  }
+  /**
+   * Check if a word appears to be a Polish verb form that can be normalized.
+   */
+  isNormalizable(word) {
+    if (word.length < 3) return false;
+    return /[a-zA-ZąęćńóśźżłĄĘĆŃÓŚŹŻŁ]/.test(word);
+  }
+  /**
+   * Normalize a Polish verb to its base/infinitive form.
+   */
+  normalize(word) {
+    const lower = word.toLowerCase();
+    if (this.isInfinitive(lower)) {
+      return noChange(lower);
+    }
+    const imperativeResult = this.tryImperativeNormalization(lower);
+    if (imperativeResult) return imperativeResult;
+    const pastResult = this.tryPastTenseNormalization(lower);
+    if (pastResult) return pastResult;
+    const presentResult = this.tryPresentTenseNormalization(lower);
+    if (presentResult) return presentResult;
+    return noChange(lower);
+  }
+  /**
+   * Check if word is already in infinitive form.
+   */
+  isInfinitive(word) {
+    const infinitiveEndings = ["a\u0107", "e\u0107", "i\u0107", "y\u0107", "\u0105\u0107", "owa\u0107", "iwa\u0107", "ywa\u0107"];
+    return infinitiveEndings.some((ending) => word.endsWith(ending));
+  }
+  /**
+   * Try to normalize imperative form to infinitive.
+   *
+   * Polish imperative (2nd person singular) patterns:
+   * - pisać → pisz (write)
+   * - czytać → czytaj (read)
+   * - robić → rób (do)
+   * - mówić → mów (speak)
+   * - uczyć → ucz (teach)
+   */
+  tryImperativeNormalization(word) {
+    if (IMPERATIVE_TO_INFINITIVE.has(word)) {
+      return normalized(IMPERATIVE_TO_INFINITIVE.get(word), 0.95, {
+        removedSuffixes: ["imperative"],
+        conjugationType: "imperative"
+      });
+    }
+    if (word.endsWith("aj")) {
+      return normalized(word.slice(0, -2) + "a\u0107", 0.8, {
+        removedSuffixes: ["aj"],
+        conjugationType: "imperative"
+      });
+    }
+    if (word.endsWith("uj")) {
+      return normalized(word.slice(0, -2) + "owa\u0107", 0.8, {
+        removedSuffixes: ["uj"],
+        conjugationType: "imperative"
+      });
+    }
+    if (word.endsWith("ij")) {
+      return normalized(word.slice(0, -2) + "i\u0107", 0.75, {
+        removedSuffixes: ["ij"],
+        conjugationType: "imperative"
+      });
+    }
+    return null;
+  }
+  /**
+   * Try to normalize present tense form to infinitive.
+   */
+  tryPresentTenseNormalization(word) {
+    if (word.endsWith("uj\u0119") || word.endsWith("uje")) {
+      return normalized(word.slice(0, -3) + "owa\u0107", 0.85, {
+        removedSuffixes: ["uj\u0119"],
+        conjugationType: "present"
+      });
+    }
+    if (word.endsWith("am") && word.length > 3) {
+      return normalized(word.slice(0, -2) + "a\u0107", 0.8, {
+        removedSuffixes: ["am"],
+        conjugationType: "present"
+      });
+    }
+    if (word.endsWith("em") && word.length > 3) {
+      return normalized(word.slice(0, -2) + "e\u0107", 0.75, {
+        removedSuffixes: ["em"],
+        conjugationType: "present"
+      });
+    }
+    if (word.endsWith("\u0119") && word.length > 2) {
+      return normalized(word.slice(0, -1) + "a\u0107", 0.7, {
+        removedSuffixes: ["\u0119"],
+        conjugationType: "present"
+      });
+    }
+    return null;
+  }
+  /**
+   * Try to normalize past tense form to infinitive.
+   */
+  tryPastTenseNormalization(word) {
+    if (word.endsWith("a\u0142em") || word.endsWith("a\u0142am")) {
+      return normalized(word.slice(0, -4) + "a\u0107", 0.85, {
+        removedSuffixes: [word.slice(-4)],
+        conjugationType: "past"
+      });
+    }
+    if (word.endsWith("a\u0142") || word.endsWith("a\u0142a")) {
+      const suffixLen = word.endsWith("a\u0142a") ? 3 : 2;
+      return normalized(word.slice(0, -suffixLen) + "a\u0107", 0.8, {
+        removedSuffixes: [word.slice(-suffixLen)],
+        conjugationType: "past"
+      });
+    }
+    if (word.endsWith("i\u0142em") || word.endsWith("i\u0142am") || word.endsWith("ilem") || word.endsWith("ilam")) {
+      return normalized(word.slice(0, -4) + "i\u0107", 0.85, {
+        removedSuffixes: [word.slice(-4)],
+        conjugationType: "past"
+      });
+    }
+    if (word.endsWith("i\u0142") || word.endsWith("i\u0142a") || word.endsWith("il") || word.endsWith("ila")) {
+      const suffixLen = word.endsWith("i\u0142a") || word.endsWith("ila") ? 3 : 2;
+      return normalized(word.slice(0, -suffixLen) + "i\u0107", 0.8, {
+        removedSuffixes: [word.slice(-suffixLen)],
+        conjugationType: "past"
+      });
+    }
+    return null;
+  }
+};
+var polishMorphologicalNormalizer = new PolishMorphologicalNormalizer();
+
+// src/tokenizers/polish.ts
+var { isLetter: isPolishLetter, isIdentifierChar: isPolishIdentifierChar } = createLatinCharClassifiers(/[a-zA-ZąęćńóśźżłĄĘĆŃÓŚŹŻŁ]/);
+var PREPOSITIONS = /* @__PURE__ */ new Set([
+  "do",
+  // to, into
+  "od",
+  // from
+  "z",
+  // from, with
+  "ze",
+  // from, with (before consonant clusters)
+  "w",
+  // in
+  "we",
+  // in (before consonant clusters)
+  "na",
+  // on, for
+  "po",
+  // after, for
+  "pod",
+  // under
+  "przed",
+  // before, in front of
+  "za",
+  // behind, for
+  "nad",
+  // above
+  "mi\u0119dzy",
+  // between
+  "miedzy",
+  // between (no diacritic)
+  "przez",
+  // through, by
+  "dla",
+  // for
+  "bez",
+  // without
+  "o",
+  // about
+  "przy",
+  // at, by
+  "u",
+  // at (someone's place)
+  "wed\u0142ug",
+  // according to
+  "wedlug",
+  // according to (no diacritic)
+  "mimo",
+  // despite
+  "w\u015Br\xF3d",
+  // among
+  "wsrod",
+  // among (no diacritic)
+  "obok",
+  // beside
+  "poza",
+  // outside, beyond
+  "wok\xF3\u0142",
+  // around
+  "wokol",
+  // around (no diacritic)
+  "przeciw",
+  // against
+  "ku"
+  // towards
+]);
+var POLISH_EXTRAS = [
+  // Values/Literals
+  { native: "prawda", normalized: "true" },
+  { native: "fa\u0142sz", normalized: "false" },
+  { native: "falsz", normalized: "false" },
+  { native: "null", normalized: "null" },
+  { native: "nieokre\u015Blony", normalized: "undefined" },
+  { native: "nieokreslony", normalized: "undefined" },
+  // Positional
+  { native: "pierwszy", normalized: "first" },
+  { native: "pierwsza", normalized: "first" },
+  { native: "pierwsze", normalized: "first" },
+  { native: "ostatni", normalized: "last" },
+  { native: "ostatnia", normalized: "last" },
+  { native: "ostatnie", normalized: "last" },
+  { native: "nast\u0119pny", normalized: "next" },
+  { native: "nastepny", normalized: "next" },
+  { native: "poprzedni", normalized: "previous" },
+  { native: "najbli\u017Cszy", normalized: "closest" },
+  { native: "najblizszy", normalized: "closest" },
+  { native: "rodzic", normalized: "parent" },
+  // Events
+  { native: "klikni\u0119cie", normalized: "click" },
+  { native: "klikniecie", normalized: "click" },
+  { native: "klik", normalized: "click" },
+  { native: "click", normalized: "click" },
+  { native: "zmiana", normalized: "change" },
+  { native: "wys\u0142anie", normalized: "submit" },
+  { native: "wyslanie", normalized: "submit" },
+  { native: "naci\u015Bni\u0119cie", normalized: "keydown" },
+  { native: "nacisniecie", normalized: "keydown" },
+  { native: "klawisz", normalized: "keydown" },
+  { native: "najechanie", normalized: "mouseover" },
+  { native: "zjechanie", normalized: "mouseout" },
+  { native: "rozmycie", normalized: "blur" },
+  { native: "za\u0142adowanie", normalized: "load" },
+  { native: "zaladowanie", normalized: "load" },
+  { native: "przewini\u0119cie", normalized: "scroll" },
+  { native: "przewiniecie", normalized: "scroll" },
+  { native: "input", normalized: "input" },
+  // References
+  { native: "m\xF3j", normalized: "my" },
+  { native: "moj", normalized: "my" },
+  // Time units
+  { native: "sekunda", normalized: "s" },
+  { native: "sekundy", normalized: "s" },
+  { native: "sekund", normalized: "s" },
+  { native: "milisekunda", normalized: "ms" },
+  { native: "milisekundy", normalized: "ms" },
+  { native: "milisekund", normalized: "ms" },
+  { native: "minuta", normalized: "m" },
+  { native: "minuty", normalized: "m" },
+  { native: "minut", normalized: "m" },
+  { native: "godzina", normalized: "h" },
+  { native: "godziny", normalized: "h" },
+  { native: "godzin", normalized: "h" },
+  // Additional verb forms not in profile (lay/put variants)
+  { native: "po\u0142\xF3\u017C", normalized: "put" },
+  { native: "poloz", normalized: "put" },
+  // Logical/conditional
+  { native: "lub", normalized: "or" },
+  { native: "nie", normalized: "not" },
+  { native: "jest", normalized: "is" },
+  { native: "istnieje", normalized: "exists" },
+  { native: "pusty", normalized: "empty" },
+  { native: "puste", normalized: "empty" }
+];
+var PolishTokenizer = class extends BaseTokenizer {
+  constructor() {
+    super();
+    this.language = "pl";
+    this.direction = "ltr";
+    this.initializeKeywordsFromProfile(polishProfile, POLISH_EXTRAS);
+    this.normalizer = new PolishMorphologicalNormalizer();
+  }
+  tokenize(input) {
+    const tokens = [];
+    let pos = 0;
+    while (pos < input.length) {
+      if (isWhitespace(input[pos])) {
+        pos++;
+        continue;
+      }
+      if (isSelectorStart(input[pos])) {
+        const modifierToken = this.tryEventModifier(input, pos);
+        if (modifierToken) {
+          tokens.push(modifierToken);
+          pos = modifierToken.position.end;
+          continue;
+        }
+        if (this.tryPropertyAccess(input, pos, tokens)) {
+          pos++;
+          continue;
+        }
+        const selectorToken = this.trySelector(input, pos);
+        if (selectorToken) {
+          tokens.push(selectorToken);
+          pos = selectorToken.position.end;
+          continue;
+        }
+      }
+      if (isQuote(input[pos])) {
+        const stringToken = this.tryString(input, pos);
+        if (stringToken) {
+          tokens.push(stringToken);
+          pos = stringToken.position.end;
+          continue;
+        }
+      }
+      if (isUrlStart(input, pos)) {
+        const urlToken = this.tryUrl(input, pos);
+        if (urlToken) {
+          tokens.push(urlToken);
+          pos = urlToken.position.end;
+          continue;
+        }
+      }
+      if (isDigit(input[pos]) || input[pos] === "-" && pos + 1 < input.length && isDigit(input[pos + 1])) {
+        const numberToken = this.extractNumber(input, pos);
+        if (numberToken) {
+          tokens.push(numberToken);
+          pos = numberToken.position.end;
+          continue;
+        }
+      }
+      const varToken = this.tryVariableRef(input, pos);
+      if (varToken) {
+        tokens.push(varToken);
+        pos = varToken.position.end;
+        continue;
+      }
+      if (isPolishLetter(input[pos])) {
+        const wordToken = this.extractWord(input, pos);
+        if (wordToken) {
+          tokens.push(wordToken);
+          pos = wordToken.position.end;
+          continue;
+        }
+      }
+      const operatorToken = this.tryOperator(input, pos);
+      if (operatorToken) {
+        tokens.push(operatorToken);
+        pos = operatorToken.position.end;
+        continue;
+      }
+      pos++;
+    }
+    return new TokenStreamImpl(tokens, "pl");
+  }
+  classifyToken(token) {
+    const lower = token.toLowerCase();
+    if (PREPOSITIONS.has(lower)) return "particle";
+    if (this.isKeyword(lower)) return "keyword";
+    if (token.startsWith("#") || token.startsWith(".") || token.startsWith("[") || token.startsWith("*") || token.startsWith("<"))
+      return "selector";
+    if (token.startsWith('"') || token.startsWith("'")) return "literal";
+    if (/^\d/.test(token)) return "literal";
+    return "identifier";
+  }
+  extractWord(input, startPos) {
+    let pos = startPos;
+    let word = "";
+    while (pos < input.length && isPolishIdentifierChar(input[pos])) {
+      word += input[pos++];
+    }
+    if (!word) return null;
+    const lower = word.toLowerCase();
+    if (PREPOSITIONS.has(lower)) {
+      return createToken(word, "particle", createPosition(startPos, pos));
+    }
+    const keywordEntry = this.lookupKeyword(lower);
+    if (keywordEntry) {
+      return createToken(word, "keyword", createPosition(startPos, pos), keywordEntry.normalized);
+    }
+    return createToken(word, "identifier", createPosition(startPos, pos));
+  }
+  extractNumber(input, startPos) {
+    let pos = startPos;
+    let number = "";
+    if (input[pos] === "-" || input[pos] === "+") {
+      number += input[pos++];
+    }
+    while (pos < input.length && isDigit(input[pos])) {
+      number += input[pos++];
+    }
+    if (pos < input.length && input[pos] === ".") {
+      number += input[pos++];
+      while (pos < input.length && isDigit(input[pos])) {
+        number += input[pos++];
+      }
+    }
+    let unitPos = pos;
+    while (unitPos < input.length && isWhitespace(input[unitPos])) {
+      unitPos++;
+    }
+    const remaining = input.slice(unitPos).toLowerCase();
+    if (remaining.startsWith("milisekund") || remaining.startsWith("milisekunda")) {
+      number += "ms";
+      pos = unitPos + (remaining.startsWith("milisekundy") ? 11 : remaining.startsWith("milisekunda") ? 11 : 10);
+    } else if (remaining.startsWith("sekund") || remaining.startsWith("sekunda")) {
+      number += "s";
+      pos = unitPos + (remaining.startsWith("sekundy") ? 7 : remaining.startsWith("sekunda") ? 7 : 6);
+    } else if (remaining.startsWith("minut") || remaining.startsWith("minuta")) {
+      number += "m";
+      pos = unitPos + (remaining.startsWith("minuty") ? 6 : remaining.startsWith("minuta") ? 6 : 5);
+    } else if (remaining.startsWith("godzin") || remaining.startsWith("godzina")) {
+      number += "h";
+      pos = unitPos + (remaining.startsWith("godziny") ? 7 : remaining.startsWith("godzina") ? 7 : 6);
+    } else if (remaining.startsWith("ms")) {
+      number += "ms";
+      pos = unitPos + 2;
+    } else if (remaining.startsWith("s") && !remaining.startsWith("se")) {
+      number += "s";
+      pos = unitPos + 1;
+    }
+    if (!number || number === "-" || number === "+") return null;
+    return createToken(number, "literal", createPosition(startPos, pos));
+  }
+};
+var polishTokenizer = new PolishTokenizer();
+
+// src/languages/pl.ts
+registerLanguage("pl", polishTokenizer, polishProfile);
+export {
+  polishProfile,
+  polishTokenizer
+};
+//# sourceMappingURL=pl.js.map