@heartlandone/vega 2.75.1 → 2.77.0

package/dist/types/polyfill/d3/d3-selection-polyfill.d.ts

@@ -0,0 +1,173 @@
+/**
+ * D3 Selection Polyfill - A lightweight DOM selection and manipulation utility.
+ *
+ * This is a drop-in replacement for d3-selection, implementing only the methods
+ * used in the Vega chart rendering system.
+ *
+ * Supported methods: select, selectAll, append, attr, property, text, datum,
+ * call, node, nodes, each, remove, clone, transition, duration.
+ *
+ * @see VD-5022 - [Zero Dependencies] remove d3 dependency
+ */
+declare type SelectionCallback<GElement, Datum> = (this: GElement, d?: Datum, i?: number, nodes?: GElement[]) => any;
+/**
+ * A lightweight selection class mimicking d3-selection's chainable API.
+ * Wraps an array of DOM elements and provides attribute/property/child manipulation.
+ */
+export declare class D3SelectionPolyfill<GElement extends Element = Element, Datum = unknown, PElement extends Element = Element, PDatum = unknown> {
+  private _groups;
+  private _datum;
+  /**
+   * @param {Element[]} elements - Array of DOM elements to wrap.
+   * @param {*} [datum] - Optional bound datum for the selection.
+   */
+  constructor(elements: GElement[], datum?: Datum);
+  /**
+   * Selects the first descendant element matching the selector.
+   *
+   * @template DescElement
+   * @template Datum
+   * @template GElement
+   * @param {string} selector - CSS selector string.
+   * @returns {D3SelectionPolyfill<DescElement, Datum, GElement, Datum>} A new selection wrapping the matched element.
+   */
+  select<DescElement extends Element = Element>(selector: string): D3SelectionPolyfill<DescElement, Datum, GElement, Datum>;
+  /**
+   * Selects all descendant elements matching the selector.
+   *
+   * @template DescElement
+   * @template NewDatum
+   * @template GElement
+   * @template Datum
+   * @param {string} selector - CSS selector string.
+   * @returns {D3SelectionPolyfill<DescElement, NewDatum, GElement, Datum>} A new selection wrapping all matched elements.
+   */
+  selectAll<DescElement extends Element = Element, NewDatum = unknown>(selector: string): D3SelectionPolyfill<DescElement, NewDatum, GElement, Datum>;
+  /**
+   * Appends a new child element to each element in the selection.
+   * Accepts either a tag name string or a factory function that returns a DOM element.
+   *
+   * @template ChildElement
+   * @template Datum
+   * @template GElement
+   * @param {string | Function} tagOrFactory - Tag name (e.g. 'g', 'path') or a factory function.
+   * @returns {D3SelectionPolyfill<ChildElement, Datum, GElement, Datum>} A new selection wrapping the appended elements.
+   */
+  append<ChildElement extends Element = Element>(tagOrFactory: string | (() => ChildElement)): D3SelectionPolyfill<ChildElement, Datum, GElement, Datum>;
+  /**
+   * Sets or gets an attribute on each element.
+   * If value is a function, it is called with the bound datum.
+   *
+   * @param {...*} args - Attribute name, and optionally a value or function returning a value.
+   * @returns {any} This selection for chaining, or the attribute value if getting.
+   */
+  attr(...args: any[]): any;
+  /**
+   * Sets a JavaScript property on each element.
+   *
+   * @param {string} name - Property name.
+   * @param {unknown} value - Property value.
+   * @returns {this} This selection for chaining.
+   */
+  property(name: string, value: unknown): this;
+  /**
+   * Sets the text content of each element.
+   *
+   * @param {string} value - Text content string.
+   * @returns {this} This selection for chaining.
+   */
+  text(value: string): this;
+  /**
+   * Binds a datum to the selection.
+   *
+   * @template NewDatum
+   * @template GElement
+   * @template PElement
+   * @template PDatum
+   * @param {*} data - The datum to bind.
+   * @returns {D3SelectionPolyfill<GElement, NewDatum, PElement, PDatum>} A new selection with the bound datum.
+   */
+  datum<NewDatum>(data: NewDatum): D3SelectionPolyfill<GElement, NewDatum, PElement, PDatum>;
+  /**
+   * Calls a function with this selection as argument. Used for grouping operations.
+   *
+   * @param {Function} fn - Function to call.
+   * @param {...*} args - Additional arguments.
+   * @returns {this} This selection for chaining.
+   */
+  call(fn: (selection: this, ...args: any[]) => void, ...args: any[]): this;
+  /**
+   * Returns the first DOM node in the selection, or null.
+   *
+   * @template GElement
+   * @returns {GElement | null} The first element or null.
+   */
+  node(): GElement | null;
+  /**
+   * Returns all DOM nodes in the selection as an array.
+   *
+   * @template GElement
+   * @returns {GElement[]} Array of elements.
+   */
+  nodes(): GElement[];
+  /**
+   * Iterates over each element, calling the provided function.
+   * The function is called with `this` set to the current DOM element.
+   *
+   * @param {Function} fn - Callback function.
+   * @returns {this} This selection for chaining.
+   */
+  each(fn: SelectionCallback<GElement, Datum>): this;
+  /**
+   * Removes all elements in the selection from the DOM.
+   *
+   * @returns {this} This selection for chaining.
+   */
+  remove(): this;
+  /**
+   * Clones each element in the selection (shallow clone) and inserts after the original.
+   *
+   * @template GElement
+   * @template Datum
+   * @template PElement
+   * @template PDatum
+   * @returns {D3SelectionPolyfill<GElement, Datum, PElement, PDatum>} A new selection wrapping the cloned elements.
+   */
+  clone(): D3SelectionPolyfill<GElement, Datum, PElement, PDatum>;
+  /**
+   * Creates a transition-like object. This is a simplified polyfill that
+   * applies attribute changes immediately (no actual animation), which is
+   * sufficient for Vega's usage of hover path swapping.
+   *
+   * @param {*} [_name] - Transition name (ignored in polyfill).
+   * @returns {this} This selection for chaining (acts as a no-op).
+   */
+  transition(_name?: unknown): this;
+  /**
+   * Sets the transition duration. No-op in this polyfill since
+   * transitions are applied immediately.
+   *
+   * @param {number} _ms - Duration in milliseconds (ignored).
+   * @returns {this} This selection for chaining.
+   */
+  duration(_ms: number): this;
+}
+/**
+ * Selects a DOM element by wrapping it in a D3SelectionPolyfill.
+ * Mimics d3.select().
+ *
+ * @template GElement
+ * @param {Element | EventTarget} element - A DOM element or EventTarget to wrap.
+ * @returns {D3SelectionPolyfill<GElement>} A new D3SelectionPolyfill wrapping the element.
+ */
+export declare function select<GElement extends Element = Element>(element: GElement | EventTarget): D3SelectionPolyfill<GElement>;
+/**
+ * Creates a detached SVG element (e.g., 'svg:text', 'svg:circle', 'svg:path').
+ * Mimics d3.create().
+ *
+ * @template GElement
+ * @param {string} qualifiedName - A qualified name like 'svg:text' or 'svg:circle'.
+ * @returns {D3SelectionPolyfill<GElement>} A new D3SelectionPolyfill wrapping the created element.
+ */
+export declare function create<GElement extends Element = Element>(qualifiedName: string): D3SelectionPolyfill<GElement>;
+export {};

package/dist/types/polyfill/d3/d3-shape-polyfill.d.ts

@@ -0,0 +1,129 @@
+/**
+ * D3 Shape Polyfill - Lightweight SVG shape generators.
+ *
+ * This is a drop-in replacement for d3-shape, implementing only the methods
+ * used in the Vega chart rendering system: line, arc, and pie.
+ *
+ * @see VD-5022 - [Zero Dependencies] remove d3 dependency
+ */
+declare type LineAccessor<T> = (d: T, i?: number) => number;
+/**
+ * A line generator that creates SVG path data strings from data arrays.
+ * Mimics d3.line() with .x() and .y() value extractors.
+ */
+declare class LineGenerator<T> {
+  /**
+   * Sets the x accessor function.
+   *
+   * @param accessor - Function that returns the x value for a datum.
+   * @returns This generator for chaining.
+   */
+  x(accessor: LineAccessor<T>): this;
+  /**
+   * Sets the y accessor function.
+   *
+   * @param accessor - Function that returns the y value for a datum.
+   * @returns This generator for chaining.
+   */
+  y(accessor: LineAccessor<T>): this;
+  /**
+   * Generates an SVG path data string for the given data.
+   * Called as a function (used by d3's attr('d', lineGenerator)).
+   *
+   * @param data - Array of data points.
+   * @returns SVG path data string (M...L...L...).
+   */
+  generate(data: T[]): string;
+  /** Default x value extractor: reads `.x` property or first array index. */
+  private xAccessor;
+  /** Default y value extractor: reads `.y` property or second array index. */
+  private yAccessor;
+}
+/**
+ * Creates a line generator. Mimics d3.line<T>().
+ * The returned object is also callable as a function for d3 compatibility.
+ *
+ * @returns A new LineGenerator with callable function interface.
+ */
+export declare function line<T = [number, number]>(): LineGenerator<T> & ((data: T[]) => string);
+/**
+ * An arc generator that creates SVG path data strings for arc/pie slices.
+ * Mimics d3.arc<T>() with .innerRadius() and .outerRadius() value setters.
+ */
+declare class ArcGenerator<T> {
+  /** Inner radius value for the arc. */
+  private innerRadiusValue;
+  /** Outer radius value for the arc. */
+  private outerRadiusValue;
+  /**
+   * Sets the inner radius for the arc.
+   *
+   * @param radius - Inner radius value.
+   * @returns This generator for chaining.
+   */
+  innerRadius(radius: number): this;
+  /**
+   * Sets the outer radius for the arc.
+   *
+   * @param radius - Outer radius value.
+   * @returns This generator for chaining.
+   */
+  outerRadius(radius: number): this;
+  /**
+   * Generates an SVG path data string for an arc datum.
+   * The datum must have startAngle and endAngle properties (in angle units).
+   *
+   * @param d - Arc datum with startAngle and endAngle.
+   * @returns SVG path data string for the arc.
+   */
+  generate(d: T): string;
+}
+/**
+ * Creates an arc generator. Mimics d3.arc<T>().
+ * The returned object is also callable as a function for d3 compatibility.
+ *
+ * @returns A new ArcGenerator with callable function interface.
+ */
+export declare function arc<T>(): ArcGenerator<T> & ((d: T) => string);
+/**
+ * A pie arc datum produced by the pie generator.
+ */
+export declare type PieArcDatum<T> = {
+  data: T;
+  index: number;
+  value: number;
+  startAngle: number;
+  endAngle: number;
+  padAngle: number;
+};
+declare type PieValueAccessor<T> = (d: T) => number;
+/**
+ * A pie layout generator that computes start/end angles for data items.
+ * Mimics d3.pie<T>() with .value() setter.
+ */
+declare class PieGenerator<T> {
+  /**
+   * Sets the value accessor function.
+   *
+   * @param accessor - Function that returns the numeric value for each datum.
+   * @returns This generator for chaining.
+   */
+  value(accessor: PieValueAccessor<T>): this & ((data: T[]) => PieArcDatum<T>[]);
+  /**
+   * Computes pie arc data from the input data array.
+   *
+   * @param data - Array of data items.
+   * @returns Array of PieArcDatum with computed angles.
+   */
+  generate(data: T[]): PieArcDatum<T>[];
+  /** Default value extractor: reads `.value` property or falls back to 0. */
+  private valueAccessor;
+}
+/**
+ * Creates a pie layout generator. Mimics d3.pie<T>().
+ * The returned object is also callable as a function for d3 compatibility.
+ *
+ * @returns A new PieGenerator with callable function interface.
+ */
+export declare function pie<T>(): PieGenerator<T> & ((data: T[]) => PieArcDatum<T>[]);
+export {};

package/dist/types/polyfill/d3/d3-time-format-polyfill.d.ts

@@ -0,0 +1,28 @@
+/**
+ * D3 Time Format Polyfill - Lightweight date formatting and parsing.
+ *
+ * This is a drop-in replacement for d3-time-format, implementing only the methods
+ * used in the Vega chart rendering system: timeFormat and timeParse.
+ *
+ * @see VD-5022 - [Zero Dependencies] remove d3 dependency
+ */
+/**
+ * Creates a date formatter function for the given specifier.
+ * Mimics d3.timeFormat().
+ *
+ * Supported directives: %Y, %m, %d, %H, %I, %M, %S, %L, %b, %B, %a, %p, %%
+ *
+ * @param {string} specifier - Format specifier string (e.g., '%Y-%m-%d', '.%L', ':%S').
+ * @returns {Function} A function that formats a Date into a string.
+ */
+export declare function timeFormat(specifier: string): (date: Date) => string;
+/**
+ * Creates a date parser function for the given specifier.
+ * Mimics d3.timeParse().
+ *
+ * Supported directives: %Y, %m, %d, %H, %I, %M, %S, %L
+ *
+ * @param {string} specifier - Parse specifier string (e.g., '%Y-%m-%d').
+ * @returns {Function} A function that parses a string into a Date, or null on failure.
+ */
+export declare function timeParse(specifier: string): (dateString: string) => Date | null;

package/dist/types/polyfill/d3/d3-time-polyfill.d.ts

@@ -0,0 +1,68 @@
+/**
+ * D3 Time Polyfill - Lightweight time interval functions.
+ *
+ * This is a drop-in replacement for d3-time, implementing only the time interval
+ * floor functions used in the Vega chart time axis label formatter:
+ * timeSecond, timeMinute, timeHour, timeDay, timeWeek, timeMonth, timeYear.
+ *
+ * Each function floors a Date to the nearest interval boundary, which is used
+ * to determine the appropriate label granularity for time-series chart axes.
+ *
+ * @see VD-5022 - [Zero Dependencies] remove d3 dependency
+ */
+/**
+ * Floors a date to the nearest second boundary.
+ * Used to detect sub-second (millisecond) granularity.
+ *
+ * @param {Date} date - Input date.
+ * @returns {Date} A new Date floored to the nearest second.
+ */
+export declare function timeSecond(date: Date): Date;
+/**
+ * Floors a date to the nearest minute boundary.
+ * Used to detect sub-minute (second) granularity.
+ *
+ * @param {Date} date - Input date.
+ * @returns {Date} A new Date floored to the nearest minute.
+ */
+export declare function timeMinute(date: Date): Date;
+/**
+ * Floors a date to the nearest hour boundary.
+ * Used to detect sub-hour (minute) granularity.
+ *
+ * @param {Date} date - Input date.
+ * @returns {Date} A new Date floored to the nearest hour.
+ */
+export declare function timeHour(date: Date): Date;
+/**
+ * Floors a date to the start of the day (midnight).
+ * Used to detect sub-day (hour) granularity.
+ *
+ * @param {Date} date - Input date.
+ * @returns {Date} A new Date floored to midnight.
+ */
+export declare function timeDay(date: Date): Date;
+/**
+ * Floors a date to the start of the week (Sunday).
+ * Used to distinguish day vs week label granularity.
+ *
+ * @param {Date} date - Input date.
+ * @returns {Date} A new Date floored to the start of the week (Sunday at midnight).
+ */
+export declare function timeWeek(date: Date): Date;
+/**
+ * Floors a date to the first of the month.
+ * Used to detect sub-month granularity.
+ *
+ * @param {Date} date - Input date.
+ * @returns {Date} A new Date floored to the 1st of the month at midnight.
+ */
+export declare function timeMonth(date: Date): Date;
+/**
+ * Floors a date to January 1st of the year.
+ * Used to detect sub-year (month) granularity.
+ *
+ * @param {Date} date - Input date.
+ * @returns {Date} A new Date floored to January 1st at midnight.
+ */
+export declare function timeYear(date: Date): Date;

package/dist/types/polyfill/d3/index.d.ts

@@ -0,0 +1,27 @@
+/**
+ * D3 Polyfill - A lightweight drop-in replacement for the d3 library.
+ *
+ * This module re-exports only the d3 functions and types used by the Vega
+ * chart rendering system, implemented without any external dependencies.
+ *
+ * Replaces the following d3 sub-packages:
+ * - d3-selection: select, create
+ * - d3-shape: line, arc, pie
+ * - d3-scale: scaleLinear, scaleTime, scaleBand
+ * - d3-axis: axisBottom, axisLeft, AxisDomain, AxisScale, Axis
+ * - d3-array: min, max, extent, map
+ * - d3-time-format: timeFormat, timeParse
+ * - d3-time: timeSecond, timeMinute, timeHour, timeDay, timeWeek, timeMonth, timeYear
+ *
+ * @see VD-5022 - [Zero Dependencies] remove d3 dependency
+ */
+export { select, create, D3SelectionPolyfill } from './d3-selection-polyfill';
+export { line, arc, pie } from './d3-shape-polyfill';
+export type { PieArcDatum } from './d3-shape-polyfill';
+export { scaleLinear, scaleTime, scaleBand } from './d3-scale-polyfill';
+export { axisBottom, axisLeft } from './d3-axis-polyfill';
+export type { AxisDomain, AxisScale, Axis } from './d3-axis-polyfill';
+export { min, max, extent, map } from './d3-array-polyfill';
+export { timeFormat, timeParse } from './d3-time-format-polyfill';
+export { timeSecond, timeMinute, timeHour, timeDay, timeWeek, timeMonth, timeYear } from './d3-time-polyfill';
+export declare type Selection<GElement extends Element, Datum, PElement extends Element, PDatum> = import('./d3-selection-polyfill').D3SelectionPolyfill<GElement, Datum, PElement, PDatum>;

package/dist/types/polyfill/d3/test/d3-array-polyfill.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/polyfill/d3/test/d3-axis-polyfill.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/polyfill/d3/test/d3-integration.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/polyfill/d3/test/d3-scale-polyfill.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/polyfill/d3/test/d3-selection-polyfill.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/polyfill/d3/test/d3-shape-polyfill.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/polyfill/d3/test/d3-time-format-polyfill.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/polyfill/d3/test/d3-time-polyfill.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/polyfill/d3/test/index.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/types/polyfill/libphonenumber/as-you-type.d.ts

@@ -0,0 +1,154 @@
+/**
+ * Progressive as-you-type phone number formatter for the libphonenumber polyfill.
+ */
+import type { VegaCountryCode } from '../../types/flag.type';
+/**
+ * Format a possibly-incomplete phone number for display.
+ *
+ * Internally uses AsYouType to produce correct progressive formatting.
+ *
+ * @param {string} number - the raw phone number string to format
+ * @param {VegaCountryCode} [country] - optional default country code
+ * @returns {string} the formatted incomplete phone number
+ * @example formatIncompletePhoneNumber('3023334444', 'US') // '(302) 333-4444'
+ * @example formatIncompletePhoneNumber('+13023334444')      // '+1 302 333 4444'
+ */
+export declare function formatIncompletePhoneNumber(number: string, country?: VegaCountryCode): string;
+/**
+ * Progressive phone number formatter.
+ *
+ * Internally uses template-based formatting matching libphonenumber-js.
+ */
+export declare class AsYouType {
+  private _country;
+  private _allDigits;
+  private _hasPlus;
+  private _callingCode;
+  private _nationalNumber;
+  private _matchingFormats;
+  private _chosenFormat;
+  private _populatedTemplate;
+  private _populatedPosition;
+  /**
+   * Stores a complex prefix (e.g. national prefix captured groups) that was
+   * stripped from the national number. This prefix is re-prepended when
+   * producing output.  Mirrors `complexPrefixBeforeNationalSignificantNumber`
+   * in the original library.
+   */
+  private _complexPrefix;
+  constructor(defaultCountry?: VegaCountryCode);
+  /**
+   * The currently detected country.
+   *
+   * @returns {VegaCountryCode | undefined} the detected country code or undefined
+   */
+  get country(): VegaCountryCode | undefined;
+  /**
+   * Feed characters into the formatter. Returns the formatted number so far.
+   *
+   * The original library processes one digit at a time, running narrow-down
+   * and format logic after each digit.  This is critical because formats may
+   * be eliminated at intermediate digit counts, triggering national-prefix
+   * re-extraction that changes the output structure.  We replicate that
+   * behavior here by looping over each digit individually.
+   *
+   * @param {string} text - the raw input characters to process
+   * @returns {string} the formatted phone number so far
+   */
+  input(text: string): string;
+  /**
+   * Update internal state after a new digit is added.
+   * Detects calling code and country for international numbers,
+   * or keeps the full digit string as the national number in national mode.
+   *
+   * @returns {void}
+   */
+  private updateState;
+  /**
+   * Initialize the list of candidate format rules for a given country.
+   * Filters out formats that alter the number or do not suit the current mode.
+   *
+   * @param {VegaCountryCode} country - the country whose formats to load
+   * @returns {void}
+   */
+  private initFormats;
+  /**
+   * Narrow down matching formats based on the leading digits of the national number.
+   * Removes formats that no longer match and resets the chosen format if it was eliminated.
+   *
+   * @returns {void}
+   */
+  private narrowDownFormats;
+  /**
+   * Attempt to format the national number after a new digit is added.
+   * Tries complete formatting first, then template-based, then chooses a new format.
+   *
+   * @param {string} newDigits - the newly added digit characters
+   * @returns {string | undefined} the formatted national number or undefined if no format applies
+   */
+  private formatDigit;
+  /**
+   * Try to format the national number as a complete number using the matching format rules.
+   * Only attempts formatting when the number length is a possible length for the country.
+   *
+   * @returns {string | undefined} the formatted number if a complete match is found, or undefined
+   */
+  private tryFormatComplete;
+  /**
+   * Choose a new format from the remaining candidates and apply it to the national number.
+   * Builds a template for each candidate and returns the formatted result on first match.
+   *
+   * @returns {string | undefined} the formatted national number or undefined if no format matches
+   */
+  private chooseFormatAndApply;
+  /**
+   * Insert digits into the current populated template one at a time.
+   * Replaces placeholder characters with the actual digits.
+   *
+   * @param {string} digits - the digit characters to insert into the template
+   * @returns {string | undefined} the partially formatted string or undefined if the template is exhausted
+   */
+  private formatNextDigits;
+  /**
+   * Fill an entire template string with the given digits.
+   * Used to synchronize the template state after a complete format match.
+   *
+   * @param {string} template - the format template containing digit placeholders
+   * @param {string} digits - the digit characters to populate the template with
+   * @returns {PopulatedTemplateResult | undefined} the filled template and last position, or undefined if the template ran out of placeholders
+   */
+  private populateTemplateFull;
+  /**
+   * Reset the chosen format, populated template, and position to their initial values.
+   *
+   * @returns {void}
+   */
+  private resetFormat;
+  /**
+   * Try to extract a national prefix from the current national number.
+   * Uses the country's `nationalPrefixForParsing` pattern (metadata index [7]).
+   *
+   * Called proactively on every digit input, mirroring the original library's
+   * `reExtractNationalSignificantNumber`.  When extraction first succeeds
+   * (or the extracted prefix changes), formats are re-initialized so that
+   * only formats appropriate for the shorter national number remain.
+   *
+   * @returns {void}
+   */
+  private tryReExtractNationalPrefix;
+  /**
+   * Build the full output string by prepending the calling code or complex prefix
+   * to the formatted national number.
+   *
+   * @param {string} formattedNational - the formatted national number portion
+   * @returns {string} the complete formatted phone number with prefix
+   */
+  private getFullOutput;
+  /**
+   * Produce a fallback output when no format template matches.
+   * Returns the raw digits with the plus sign or complex prefix if applicable.
+   *
+   * @returns {string} the non-formatted output string
+   */
+  private getNonFormattedOutput;
+}

package/dist/types/polyfill/libphonenumber/format-helpers.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Template-based formatting utilities for the libphonenumber polyfill.
+ *
+ * These helpers replicate the progressive formatting logic used by
+ * libphonenumber-js to produce as-you-type output.
+ */
+import type { FormatRule } from './types';
+/**
+ * Check whether a format's replacement template only uses captured groups
+ * (doesn't insert extra digits). This mirrors NON_ALTERING_FORMAT_REG_EXP
+ * in the original library.
+ *
+ * @param {string} replacement - the replacement string to test
+ * @returns {boolean} true if the format is non-altering
+ */
+export declare function isNonAlteringFormat(replacement: string): boolean;
+/**
+ * Check if a format is suitable given the current formatting context.
+ * Mirrors formatSuits() from the original library's AsYouTypeFormatter.
+ *
+ * @param {FormatRule} formatRule - the format rule to check
+ * @param {boolean} international - whether the number is international
+ * @param {boolean} nationalPrefix - whether a national prefix is present
+ * @returns {boolean} true if the format is suitable
+ */
+export declare function formatSuits(formatRule: FormatRule, international: boolean, nationalPrefix: boolean): boolean;
+/**
+ * Check whether a format's leading digits match the given national number.
+ *
+ * @param {FormatRule} formatRule - the format rule to check
+ * @param {string} nationalNumber - the national number digits
+ * @param {number} leadingDigitsPatternIndex - index into the leading digits patterns
+ * @returns {boolean} true if the leading digits match
+ */
+export declare function formatMatchesLeadingDigits(formatRule: FormatRule, nationalNumber: string, leadingDigitsPatternIndex: number): boolean;
+/**
+ * Build a formatting template for a given format rule and national number.
+ *
+ * This replicates the template-generation logic from the original library:
+ * 1. Generate a dummy number of 9s matching the format pattern.
+ * 2. Format it with the replacement template.
+ * 3. Replace each 9 with the DIGIT_PLACEHOLDER.
+ *
+ * @param {FormatRule} formatRule - the format rule to build a template from
+ * @param {number} nationalSignificantNumberLength - length of the national significant number
+ * @returns {string | undefined} the built template, or undefined if no match
+ */
+export declare function buildTemplate(formatRule: FormatRule, nationalSignificantNumberLength: number): string | undefined;
+/**
+ * Cut a template at a given position, handling closing parentheses.
+ * Matches the cut-and-strip logic from the original library.
+ *
+ * @param {string} str - the template string to cut
+ * @param {number} cutBefore - the position to cut before
+ * @returns {string} the cut and stripped template
+ */
+export declare function cutAndStripNonPairedParens(str: string, cutBefore: number): string;
+/**
+ * Apply international separator style: replace parentheses and dashes with spaces.
+ *
+ * @param {string} template - the template string to transform
+ * @returns {string} the template with international separator style applied
+ */
+export declare function applyInternationalSeparatorStyle(template: string): string;