@budiauktioner/buildi-primitives 0.1.0

package/dist/phone-number-DZ-YxCQQ.d.cts

@@ -0,0 +1,139 @@
+import { P as PrimitiveTypeInfo, T as TextCandidate } from './text-candidate-qg2bD9PY.cjs';
+import { a as Country } from './country-BhD51LDL.cjs';
+
+/** A phone country calling code (`landsnummer`) e.g. `+46` for Sweden. */
+declare class PhoneCallingCode {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly value: string;
+    readonly countryCode: string | null;
+    private constructor();
+    /** @internal */
+    static _new(value: string, countryCode: string | null): PhoneCallingCode;
+    /** @internal */
+    static fromResolvedDigits(digits: string): PhoneCallingCode;
+    static tryParse(input: string | null | undefined): PhoneCallingCode | null;
+    static parse(input: string): PhoneCallingCode;
+    static isValid(input: string | null | undefined): boolean;
+    static format(input: string | null | undefined, options?: {
+        fallbackToTrimmedInputWhenInvalid?: boolean;
+    }): string | null;
+    static normalize(input: string | null | undefined, options?: {
+        fallbackToTrimmedInputWhenInvalid?: boolean;
+    }): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    static get all(): readonly PhoneCallingCode[];
+    toNormalizedString(): string;
+    toString(): string;
+    equals(other: PhoneCallingCode | null | undefined): boolean;
+    compareTo(other: PhoneCallingCode | null | undefined): number;
+    /** Sweden (+46). */
+    static get Sweden(): PhoneCallingCode;
+    /** Norway (+47). */
+    static get Norway(): PhoneCallingCode;
+    /** Finland (+358). */
+    static get Finland(): PhoneCallingCode;
+    /** Denmark (+45). */
+    static get Denmark(): PhoneCallingCode;
+    /** Germany (+49). */
+    static get Germany(): PhoneCallingCode;
+    /** Poland (+48). */
+    static get Poland(): PhoneCallingCode;
+    /** Estonia (+372). */
+    static get Estonia(): PhoneCallingCode;
+    /** Lithuania (+370). */
+    static get Lithuania(): PhoneCallingCode;
+    /** Romania (+40). */
+    static get Romania(): PhoneCallingCode;
+    /** Bulgaria (+359). */
+    static get Bulgaria(): PhoneCallingCode;
+    /** Latvia (+371). */
+    static get Latvia(): PhoneCallingCode;
+    /** Czech Republic (+420). */
+    static get CzechRepublic(): PhoneCallingCode;
+    /** Spain (+34). */
+    static get Spain(): PhoneCallingCode;
+    /** Netherlands (+31). */
+    static get Netherlands(): PhoneCallingCode;
+    /** Greece (+30). */
+    static get Greece(): PhoneCallingCode;
+    /** Italy (+39). */
+    static get Italy(): PhoneCallingCode;
+    /** Slovenia (+386). */
+    static get Slovenia(): PhoneCallingCode;
+    /** Croatia (+385). */
+    static get Croatia(): PhoneCallingCode;
+    /** Portugal (+351). */
+    static get Portugal(): PhoneCallingCode;
+    /** Hungary (+36). */
+    static get Hungary(): PhoneCallingCode;
+    /** France (+33). */
+    static get France(): PhoneCallingCode;
+    /** Slovakia (+421). */
+    static get Slovakia(): PhoneCallingCode;
+    /** Belgium (+32). */
+    static get Belgium(): PhoneCallingCode;
+    /** United Kingdom (+44). */
+    static get UnitedKingdom(): PhoneCallingCode;
+    /** Austria (+43). */
+    static get Austria(): PhoneCallingCode;
+    /** Cyprus (+357). */
+    static get Cyprus(): PhoneCallingCode;
+    /** Iceland (+354). */
+    static get Iceland(): PhoneCallingCode;
+    /** Switzerland (+41). */
+    static get Switzerland(): PhoneCallingCode;
+    /** Ireland (+353). */
+    static get Ireland(): PhoneCallingCode;
+    /** Luxembourg (+352). */
+    static get Luxembourg(): PhoneCallingCode;
+    /** Malta (+356). */
+    static get Malta(): PhoneCallingCode;
+    /** Liechtenstein (+423). */
+    static get Liechtenstein(): PhoneCallingCode;
+    /** United States (+1). */
+    static get UnitedStates(): PhoneCallingCode;
+    /** Russia (+7). */
+    static get Russia(): PhoneCallingCode;
+}
+
+/**
+ * A phone number (`telefonnummer`). Stored normalized as `00` + country code +
+ * subscriber digits (e.g. `0046701740633`). Use {@link toE164String} for the
+ * `+`-prefixed E.164 form.
+ */
+declare class PhoneNumber {
+    static readonly typeInfo: PrimitiveTypeInfo;
+    readonly digits: string;
+    readonly countryCallingCode: PhoneCallingCode;
+    readonly country: Country | null;
+    readonly isSwedish: boolean;
+    readonly isMobile: boolean;
+    private constructor();
+    get isSwedishTestPhoneNumber(): boolean;
+    get formatted(): string;
+    static tryParse(input: string | null | undefined, defaultCallingCode?: string | PhoneCallingCode | Country | null): PhoneNumber | null;
+    static parse(input: string, defaultCallingCode?: string | PhoneCallingCode | Country | null): PhoneNumber;
+    static isValid(input: string | null | undefined, defaultCallingCode?: string | PhoneCallingCode | Country | null): boolean;
+    static format(input: string | null | undefined, options?: {
+        defaultCallingCode?: string | PhoneCallingCode | Country | null;
+        fallbackToTrimmedInputWhenInvalid?: boolean;
+    }): string | null;
+    static normalize(input: string | null | undefined, options?: {
+        defaultCallingCode?: string | PhoneCallingCode | Country | null;
+        fallbackToTrimmedInputWhenInvalid?: boolean;
+    }): string | null;
+    static isNormalized(input: string | null | undefined): boolean;
+    static findCandidatesInText(text: string): readonly TextCandidate<PhoneNumber>[];
+    toNormalizedString(): string;
+    toLocalString(defaultCallingCode?: PhoneCallingCode | Country): string;
+    toE164String(): string;
+    toInternationalString(): string;
+    toDisplayInternationalString(): string;
+    toString(): string;
+    equals(other: PhoneNumber | null | undefined): boolean;
+    compareTo(other: PhoneNumber | null | undefined): number;
+}
+/** Mask a phone number, keeping country code and last 4 digits visible. */
+declare function maskPhoneNumber(p: PhoneNumber): string;
+
+export { PhoneCallingCode as P, PhoneNumber as a, maskPhoneNumber as m };

package/dist/property/index.cjs

@@ -0,0 +1,487 @@
+'use strict';
+
+// src/primitives-defaults.ts
+var DEFAULT_CULTURE = "sv-SE";
+var DEFAULT_UI_CULTURE = "sv-SE";
+var state = {
+  culture: DEFAULT_CULTURE,
+  uiCulture: DEFAULT_UI_CULTURE};
+var PrimitivesDefaults = {
+  /**
+   * BCP-47 locale tag used for casing and number formatting.
+   * Defaults to `'sv-SE'`.
+   */
+  get culture() {
+    return state.culture;
+  },
+  set culture(value) {
+    state.culture = value;
+  },
+  /**
+   * `true` when {@link uiCulture} is Swedish (`sv` or `sv-*`).
+   * Types use this to select between localized and English display names.
+   */
+  get useLocalizedDisplayNames() {
+    const lang = state.uiCulture.toLowerCase().split("-")[0];
+    return lang === "sv";
+  }};
+
+// src/internal/input-sanitization.ts
+var FORMAT_OR_NOT_ASSIGNED = /[\p{Cf}\p{Cn}]/u;
+var SPACE_SEPARATOR = /[\p{Zs}\p{Zl}\p{Zp}]/u;
+var CONTROL = /\p{Cc}/u;
+function sanitizeInput(input) {
+  let out = "";
+  for (const c of input) {
+    if (c === "\u2018" || c === "\u2019" || c === "\u201A" || c === "\u201B") {
+      out += "'";
+      continue;
+    }
+    if (c === "\u201C" || c === "\u201D" || c === "\u201E" || c === "\u201F" || c === "\xAB" || c === "\xBB") {
+      out += '"';
+      continue;
+    }
+    if (FORMAT_OR_NOT_ASSIGNED.test(c)) {
+      continue;
+    }
+    if (CONTROL.test(c)) {
+      if (c === "	" || c === "\n" || c === "\r") out += " ";
+      continue;
+    }
+    if (SPACE_SEPARATOR.test(c)) {
+      out += " ";
+      continue;
+    }
+    out += c;
+  }
+  return out;
+}
+var WHITESPACE_RUN = /\s+/g;
+function collapseWhitespace(input) {
+  if (input == null) return "";
+  return sanitizeInput(input).trim().replace(WHITESPACE_RUN, " ");
+}
+function keepDigits(input) {
+  let out = "";
+  for (let i = 0; i < input.length; i++) {
+    const c = input.charCodeAt(i);
+    if (c >= 48 && c <= 57) out += input[i];
+  }
+  return out;
+}
+
+// src/text-scanning/text-candidate-category.ts
+var TextCandidateCategory = {
+  Property: "Property"};
+
+// src/text-scanning/text-candidate.ts
+var TextCandidate = class {
+  /** Zero-based start position in the scanned text. */
+  startIndex;
+  /** Number of characters in the original matched span. */
+  length;
+  /** The raw substring from the input text that was matched. */
+  originalText;
+  /**
+   * Short type name, e.g. `EmailAddress` or `SwedishPersonalIdentityNumber`.
+   */
+  typeName;
+  /** Broad category of the matched type. */
+  category;
+  /** Machine-comparable canonical form of the matched value. */
+  normalizedForm;
+  /** Human-readable display form of the matched value. */
+  formattedForm;
+  /**
+   * Display form with sensitive content masked (e.g. `990807-****`).
+   * Produced by the type's `toMaskedString()` helper.
+   */
+  maskedForm;
+  /** Heuristic confidence level. */
+  confidence;
+  /** The successfully parsed instance of the matched type. */
+  value;
+  constructor(opts) {
+    this.startIndex = opts.startIndex;
+    this.length = opts.length;
+    this.originalText = opts.originalText;
+    this.typeName = opts.typeName;
+    this.category = opts.category;
+    this.normalizedForm = opts.normalizedForm;
+    this.formattedForm = opts.formattedForm;
+    this.maskedForm = opts.maskedForm;
+    this.confidence = opts.confidence;
+    this.value = opts.value;
+  }
+  /** Exclusive end position (`startIndex + length`). */
+  get endIndex() {
+    return this.startIndex + this.length;
+  }
+  /** Returns `true` if this candidate's span overlaps with `other`. */
+  overlaps(other) {
+    return this.startIndex < other.endIndex && other.startIndex < this.endIndex;
+  }
+  /** Returns `true` if this candidate's span fully contains `other`. */
+  contains(other) {
+    return this.startIndex <= other.startIndex && this.endIndex >= other.endIndex;
+  }
+};
+
+// src/text-scanning/text-match-confidence.ts
+var TextMatchConfidence = {
+  /**
+   * Structural match with partial validation — the format is correct but no
+   * checksum or strong distinguishing feature confirms the match.
+   */
+  Medium: 1};
+
+// src/property/swedish-property-designation.ts
+var MAX_INPUT_LENGTH = 200;
+var PARSE_PATTERN = /^(?<name>[\p{L}\p{M}\d][\p{L}\p{M}\d\s'-]*?)\s+(?<block>\d{1,6}):(?<unit>\d{1,6})$/u;
+var SCAN_PATTERN = /(?<![\p{L}\p{M}\d])(?<name>\p{Lu}[\p{L}\p{M}'-]*(?:\s\p{Lu}[\p{L}\p{M}'-]*)?)\s+(?<block>\d{1,6}):(?<unit>\d{1,6})(?!\d)/gu;
+var SwedishPropertyDesignation = class _SwedishPropertyDesignation {
+  static typeInfo = Object.freeze({
+    englishName: "Property Designation",
+    localizedName: "Fastighetsbeteckning",
+    emoji: "\u{1F3E0}",
+    sources: Object.freeze([
+      "https://www.lantmateriet.se/sv/kartor/vara-karttjanster/min-karta/hitta-fastighetsbeteckning-i-min-karta/",
+      "https://www2.lantmateriet.se/sv/fastighet-och-mark/information-om-fastigheter/Fastighetsregistret/registrets-innehall/",
+      "https://sv.wikipedia.org/wiki/Fastighetsbeteckning"
+    ])
+  });
+  /** The full designation, e.g. `Stockholm Söder 75:2`. */
+  value;
+  /** The capitalized designation name, e.g. `Stockholm Söder`. */
+  designationName;
+  /** The register number `BLOCK:UNIT`, e.g. `75:2`. */
+  registerNumber;
+  /** Block portion of the register number. */
+  blockNumber;
+  /** Unit portion of the register number. */
+  unitNumber;
+  constructor(value, designationName, registerNumber, blockNumber, unitNumber) {
+    this.value = value;
+    this.designationName = designationName;
+    this.registerNumber = registerNumber;
+    this.blockNumber = blockNumber;
+    this.unitNumber = unitNumber;
+  }
+  static tryParse(input) {
+    if (input == null || input.trim() === "") return null;
+    const normalized = normalizeInput(input);
+    if (normalized.length > MAX_INPUT_LENGTH) return null;
+    const match = PARSE_PATTERN.exec(normalized);
+    if (!match || !match.groups) return null;
+    const name = normalizeName(match.groups.name);
+    if (name === "") return null;
+    const block = Number(match.groups.block);
+    const unit = Number(match.groups.unit);
+    if (!Number.isFinite(block) || block <= 0) return null;
+    if (!Number.isFinite(unit) || unit <= 0) return null;
+    const register = `${block}:${unit}`;
+    const value = `${name} ${register}`;
+    return new _SwedishPropertyDesignation(value, name, register, block, unit);
+  }
+  static parse(input) {
+    const r = _SwedishPropertyDesignation.tryParse(input);
+    if (r === null) throw new Error("Invalid Swedish property designation.");
+    return r;
+  }
+  static isValid(input) {
+    return _SwedishPropertyDesignation.tryParse(input) !== null;
+  }
+  static format(input, options) {
+    const r = _SwedishPropertyDesignation.tryParse(input);
+    if (r) return r.value;
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null && input.trim() !== "") {
+      return input.trim();
+    }
+    return null;
+  }
+  static normalize(input, options) {
+    return _SwedishPropertyDesignation.format(input, options);
+  }
+  static isNormalized(input) {
+    return input != null && _SwedishPropertyDesignation.normalize(input) === input;
+  }
+  toNormalizedString() {
+    return this.value;
+  }
+  toString() {
+    return this.value;
+  }
+  static findCandidatesInText(text) {
+    if (!text) return [];
+    const out = [];
+    const re = new RegExp(SCAN_PATTERN.source, SCAN_PATTERN.flags);
+    let m;
+    while ((m = re.exec(text)) !== null) {
+      const r = _SwedishPropertyDesignation.tryParse(m[0]);
+      if (!r) continue;
+      out.push(
+        new TextCandidate({
+          startIndex: m.index,
+          length: m[0].length,
+          originalText: m[0],
+          typeName: "SwedishPropertyDesignation",
+          category: TextCandidateCategory.Property,
+          normalizedForm: r.toNormalizedString(),
+          formattedForm: r.toString(),
+          maskedForm: maskSwedishPropertyDesignation(r),
+          confidence: TextMatchConfidence.Medium,
+          value: r
+        })
+      );
+    }
+    return out;
+  }
+  equals(other) {
+    return other != null && this.value === other.value;
+  }
+  compareTo(other) {
+    if (other == null) return 1;
+    return this.value < other.value ? -1 : this.value > other.value ? 1 : 0;
+  }
+};
+function normalizeInput(input) {
+  let s = collapseWhitespace(input);
+  s = s.replace(/\s*:\s*/g, ":");
+  return s;
+}
+function normalizeName(input) {
+  const words = collapseWhitespace(input).split(" ").filter((w) => w.length > 0);
+  return words.map(capitalizeHyphenatedWord).join(" ");
+}
+function capitalizeHyphenatedWord(word) {
+  if (!word) return word;
+  return word.split("-").map(capitalizeWord).join("-");
+}
+function capitalizeWord(word) {
+  if (!word) return word;
+  const locale = PrimitivesDefaults.culture;
+  const lowered = word.toLocaleLowerCase(locale);
+  for (let i = 0; i < lowered.length; i++) {
+    const ch = lowered[i];
+    if (isLetter(ch)) {
+      return lowered.slice(0, i) + ch.toLocaleUpperCase(locale) + lowered.slice(i + 1);
+    }
+  }
+  return lowered;
+}
+function isLetter(ch) {
+  return /\p{L}/u.test(ch);
+}
+function maskSwedishPropertyDesignation(d) {
+  const block = "*".repeat(d.blockNumber.toString().length);
+  const unit = "*".repeat(d.unitNumber.toString().length);
+  return `${d.designationName} ${block}:${unit}`;
+}
+function getLantmaterietUrl(d) {
+  return `https://minkarta.lantmateriet.se/?search=${encodeURIComponent(d.value)}`;
+}
+function getPropertyHittaUrl(d) {
+  return `https://www.hitta.se/kartan?s=${encodeURIComponent(d.value)}`;
+}
+
+// src/property/swedish-property-taxation-code.ts
+var MAX_INPUT_LENGTH2 = 20;
+var SwedishPropertyTaxationCategory = {
+  Unknown: "Unknown",
+  Lantbruksenhet: "Lantbruksenhet",
+  Smahusenhet: "Smahusenhet",
+  Hyreshusenhet: "Hyreshusenhet",
+  Industrienhet: "Industrienhet",
+  Taktmark: "Taktmark",
+  Elproduktionsenhet: "Elproduktionsenhet",
+  Specialenhet: "Specialenhet",
+  OvrigMark: "OvrigMark"
+};
+var CATEGORY_BY_FIRST_DIGIT = {
+  1: SwedishPropertyTaxationCategory.Lantbruksenhet,
+  2: SwedishPropertyTaxationCategory.Smahusenhet,
+  3: SwedishPropertyTaxationCategory.Hyreshusenhet,
+  4: SwedishPropertyTaxationCategory.Industrienhet,
+  5: SwedishPropertyTaxationCategory.Taktmark,
+  6: SwedishPropertyTaxationCategory.Elproduktionsenhet,
+  7: SwedishPropertyTaxationCategory.Specialenhet,
+  8: SwedishPropertyTaxationCategory.OvrigMark
+};
+var KNOWN_CODES = {
+  110: { english: "Agricultural unit, undeveloped", swedish: "Lantbruksenhet, obebyggd" },
+  113: {
+    english: "Agricultural unit, with farm building only",
+    swedish: "Lantbruksenhet, obebyggd, enbart med ekonomibyggnad"
+  },
+  120: { english: "Agricultural unit, developed", swedish: "Lantbruksenhet, bebyggd" },
+  210: { english: "Small house unit, land only", swedish: "Sm\xE5husenhet, tomtmark" },
+  213: {
+    english: "Small house unit, land with building value under 50 000 SEK",
+    swedish: "Sm\xE5husenhet, tomtmark med byggnadsv\xE4rde under 50 000 kr"
+  },
+  220: { english: "Small house unit, developed", swedish: "Sm\xE5husenhet, bebyggd" },
+  221: {
+    english: "Small house unit, developed with two houses",
+    swedish: "Sm\xE5husenhet, bebyggd med tv\xE5 sm\xE5hus"
+  },
+  225: {
+    english: "Small house unit, on leasehold",
+    swedish: "Sm\xE5husenhet, bebyggd p\xE5 ofri grund"
+  },
+  230: {
+    english: "Small house unit, developed, cluster housing",
+    swedish: "Sm\xE5husenhet, bebyggd, grupphusomr\xE5de"
+  },
+  310: { english: "Rental property unit, land only", swedish: "Hyreshusenhet, tomtmark" },
+  313: {
+    english: "Rental property unit, land with building value under 50 000 SEK",
+    swedish: "Hyreshusenhet, tomtmark med byggnadsv\xE4rde under 50 000 kr"
+  },
+  320: {
+    english: "Rental property unit, developed, residential",
+    swedish: "Hyreshusenhet, bebyggd, bost\xE4der"
+  },
+  321: {
+    english: "Rental property unit, developed, residential and commercial",
+    swedish: "Hyreshusenhet, bebyggd, bost\xE4der och lokaler"
+  },
+  325: {
+    english: "Rental property unit, developed, commercial",
+    swedish: "Hyreshusenhet, bebyggd, lokaler"
+  },
+  381: {
+    english: "Rental property unit, developed, residential (special)",
+    swedish: "Hyreshusenhet, bebyggd, bost\xE4der (specialenhet)"
+  },
+  410: { english: "Industrial unit, land only", swedish: "Industrienhet, tomtmark" },
+  420: { english: "Industrial unit, developed", swedish: "Industrienhet, bebyggd" },
+  421: {
+    english: "Industrial unit, developed with rental property area",
+    swedish: "Industrienhet, bebyggd med hyreshusareal"
+  },
+  498: { english: "Industrial unit, petrol station", swedish: "Industrienhet, bensinstation" },
+  510: { english: "Quarry land, undeveloped", swedish: "T\xE4ktmark, obebyggd" },
+  520: { english: "Quarry land, developed", swedish: "T\xE4ktmark, bebyggd" },
+  610: {
+    english: "Power production unit, hydropower",
+    swedish: "Elproduktionsenhet, vattenkraftverk"
+  },
+  620: {
+    english: "Power production unit, thermal power",
+    swedish: "Elproduktionsenhet, v\xE4rmekraftverk"
+  },
+  630: {
+    english: "Power production unit, wind power",
+    swedish: "Elproduktionsenhet, vindkraftverk"
+  },
+  710: { english: "Communication building", swedish: "Kommunikationsbyggnad" },
+  720: { english: "Distribution building", swedish: "Distributionsbyggnad" },
+  730: { english: "Cultural building", swedish: "Kulturbyggnad" },
+  810: { english: "Special unit, undeveloped land", swedish: "Specialenhet, obebyggd mark" },
+  890: { english: "Other land", swedish: "\xD6vrig mark" }
+};
+var SwedishPropertyTaxationCode = class _SwedishPropertyTaxationCode {
+  static typeInfo = Object.freeze({
+    englishName: "Property Taxation Code",
+    localizedName: "Typkod",
+    emoji: "\u{1F3D7}\uFE0F",
+    sources: Object.freeze([
+      "https://www.skatteverket.se/privat/fastigheterochbostad/fastighetstaxering.4.69ef368911e1304a625800013531.html",
+      "https://sv.wikipedia.org/wiki/Typkod_(fastighet)"
+    ])
+  });
+  /** The 3-digit taxation code, e.g. `220`. */
+  code;
+  /** The numeric form of the code, e.g. `220`. */
+  numericCode;
+  /** The main property category (derived from the first digit). */
+  category;
+  /** English description, or `null` when the code is not in the known list. */
+  englishDescription;
+  /** Localized (Swedish) description, or `null` when not in the known list. */
+  localizedDescription;
+  /** `true` when this code has a known description. */
+  get isKnown() {
+    return this.englishDescription !== null;
+  }
+  /** Display description in the current display language; falls back to the code. */
+  get displayDescription() {
+    const desc = PrimitivesDefaults.useLocalizedDisplayNames ? this.localizedDescription : this.englishDescription;
+    return desc ?? this.code;
+  }
+  constructor(code, numericCode, category, englishDescription, localizedDescription) {
+    this.code = code;
+    this.numericCode = numericCode;
+    this.category = category;
+    this.englishDescription = englishDescription;
+    this.localizedDescription = localizedDescription;
+  }
+  static tryParse(input) {
+    if (input == null || input.trim() === "") return null;
+    const digits = keepDigits(input);
+    if (digits.length > MAX_INPUT_LENGTH2) return null;
+    if (digits.length !== 3) return null;
+    const numeric = Number(digits);
+    if (!Number.isFinite(numeric) || numeric < 100 || numeric > 999) return null;
+    const firstDigit = Math.floor(numeric / 100);
+    const category = CATEGORY_BY_FIRST_DIGIT[firstDigit];
+    if (!category || category === SwedishPropertyTaxationCategory.Unknown) return null;
+    const known = KNOWN_CODES[numeric];
+    return new _SwedishPropertyTaxationCode(
+      digits,
+      numeric,
+      category,
+      known?.english ?? null,
+      known?.swedish ?? null
+    );
+  }
+  static parse(input) {
+    const r = _SwedishPropertyTaxationCode.tryParse(input);
+    if (r === null) throw new Error("Invalid Swedish property taxation code.");
+    return r;
+  }
+  static isValid(input) {
+    return _SwedishPropertyTaxationCode.tryParse(input) !== null;
+  }
+  static format(input, options) {
+    const r = _SwedishPropertyTaxationCode.tryParse(input);
+    if (r) return r.displayDescription;
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null && input.trim() !== "") {
+      return input.trim();
+    }
+    return null;
+  }
+  static normalize(input, options) {
+    const r = _SwedishPropertyTaxationCode.tryParse(input);
+    if (r) return r.code;
+    if (options?.fallbackToTrimmedInputWhenInvalid && input != null && input.trim() !== "") {
+      return input.trim();
+    }
+    return null;
+  }
+  static isNormalized(input) {
+    return input != null && _SwedishPropertyTaxationCode.normalize(input) === input;
+  }
+  toNormalizedString() {
+    return this.code;
+  }
+  toString() {
+    return this.displayDescription;
+  }
+  equals(other) {
+    return other != null && this.code === other.code;
+  }
+  compareTo(other) {
+    if (other == null) return 1;
+    return this.code < other.code ? -1 : this.code > other.code ? 1 : 0;
+  }
+};
+
+exports.SwedishPropertyDesignation = SwedishPropertyDesignation;
+exports.SwedishPropertyTaxationCategory = SwedishPropertyTaxationCategory;
+exports.SwedishPropertyTaxationCode = SwedishPropertyTaxationCode;
+exports.getLantmaterietUrl = getLantmaterietUrl;
+exports.getPropertyHittaUrl = getPropertyHittaUrl;
+exports.maskSwedishPropertyDesignation = maskSwedishPropertyDesignation;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map