@heartlandone/vega 2.75.0 → 2.76.0

package/dist/types/helpers/code-format/code-formatter.d.ts

@@ -6,7 +6,20 @@ export declare type CodeFormatOptions = {
  * Class to format HTML code with proper indentation and style cleanup.
  */
 declare class CodeFormatter {
+  /**
+   * Inline/phrasing elements that should be kept on a single line with their content.
+   * These tags are formatted as: <tag>content</tag> on one line.
+   */
   private static readonly INLINE_TAGS;
+  /**
+   * Void/self-closing elements that don't have closing tags.
+   * Used to avoid increasing indentation for these elements.
+   */
+  private static readonly VOID_TAGS;
+  /**
+   * Tags whose content should be preserved as-is without formatting.
+   */
+  private static readonly PRESERVE_CONTENT_TAGS;
   /**
    * Extracts the tag name from an HTML tag string.
    *
@@ -16,6 +29,7 @@ declare class CodeFormatter {
   private static getTagName;
   /**
    * Formats a given HTML source string by applying indentation and cleaning up styles.
+   * Content inside preserve tags (pre) is preserved as-is without formatting.
    *
    * @param {string} source - The HTML source string to format.
    * @param {CodeFormatOptions} options - Formatting options.

package/dist/types/helpers/common/index.d.ts

@@ -1,15 +1,2 @@
-import { HTMLVegaElementType } from './wait-for-vega-handler';
-import { HTMLStencilElement } from '../../stencil-public-runtime';
-/**
- * Wait for all vega elements to be ready.
- *
- * The below method is e2e-test covered in @see{module:wait-for-vega-should-work-as-expected}
- */
-export declare const waitForVega: () => Promise<Awaited<HTMLVegaElementType>[]>;
-/**
- * Wait for the component has been rendered.
- *
- * @param {HTMLStencilElement} componentRef - The reference to the component that needs to be rendered.
- * @returns {Promise<unknown>} A promise that resolves when the component has been rendered.
- */
-export declare const waitForComponentDidRender: (componentRef: HTMLStencilElement) => Promise<unknown>;
+export { waitForVega } from './wait-for-vega-handler';
+export { waitForComponentDidRender } from './wait-for-component-did-render';

package/dist/types/helpers/common/wait-for-component-did-render.d.ts

@@ -0,0 +1,8 @@
+import { HTMLStencilElement } from '../../stencil-public-runtime';
+/**
+ * Wait for the component has been rendered.
+ *
+ * @param {HTMLStencilElement} componentRef - The reference to the component that needs to be rendered.
+ * @returns {Promise<unknown>} A promise that resolves when the component has been rendered.
+ */
+export declare const waitForComponentDidRender: (componentRef: HTMLStencilElement) => Promise<unknown>;

package/dist/types/helpers/common/wait-for-vega-handler.d.ts

@@ -1,19 +1,10 @@
 import { VegaComponentInterface } from '../../types/ui.type';
-import { VegaPublicAPIRuntimeMetricsSlimmerBase } from '../slimmers/runtime-metrics/public-api-runtime-metrics-slimmer-base';
 export declare type HTMLVegaElementType = VegaComponentInterface<any>;
 /**
- * WaitForVegaHandler to check whether the vega component has been loaded.
+ * Wait for all vega elements to be ready.
+ *
+ * The below method is e2e-test covered in @see{module:wait-for-vega-should-work-as-expected}
+ *
+ * @returns {Promise} A promise that resolves when all vega elements are ready.
  */
-declare class WaitForVegaHandler {
-  protected vegaPublicAPIRuntimeMetricsSlimmer: VegaPublicAPIRuntimeMetricsSlimmerBase;
-  /**
-   * Wait for all vega elements to be ready.
-   *
-   * The below method is e2e-test covered in @see{module:wait-for-vega-should-work-as-expected}
-   *
-   * @vegaVersion 2.8.0
-   */
-  handle(): Promise<Awaited<HTMLVegaElementType>[]>;
-}
-export declare const WaitForVega: WaitForVegaHandler;
-export {};
+export declare const waitForVega: () => Promise<Awaited<HTMLVegaElementType>[]>;

package/dist/types/helpers/feature-control/feature-flag.d.ts

@@ -59,4 +59,5 @@ export type FeatureFlagKey =
 	| 'VEGA_TABLE.REVERSE_SORT_ORDER'
 	| 'VEGA_PAGINATION.ENABLE_EXTENSIONS_RESPONSIVE_DEFAULT_VALUE'
 	| 'VEGA_COMPONENT.CORNERS_USE_OLD_BEHAVIOR'
-	| 'VEGA_INPUT_PHONE_NUMBER.ENABLE_CALCULATION_POSITION_BY_SCREEN';
+	| 'VEGA_INPUT_PHONE_NUMBER.ENABLE_CALCULATION_POSITION_BY_SCREEN'
+	| 'VEGA_ELEMENT_APPENDER.AUTO_PLACEMENT';

package/dist/types/helpers/public-api.d.ts

@@ -15,6 +15,4 @@ export { waitForVega } from './common';
 export { IconPayload } from './icon/interface';
 export { VegaSkeletonLoader } from './skeleton-loader/vega-skeleton-loader-controller';
 export { VegaTranslation, en as VegaTranslationResourceEN } from './translation';
-export { VegaRTEContent } from '../components/vega-rich-text-editor/dto/content-state';
 export { setVegaNonce } from './csp/vega-nonce-manager';
-export * from '../components/vega-rich-text-editor/public-api';

package/dist/types/helpers/slimmers/mutation-observer/aria-attributes-value-mapper.d.ts

@@ -0,0 +1,44 @@
+import { MutationObserverSlimmer } from './mutation-observer-slimmer';
+export declare type AriaAttrDependency = {
+  dependency: string[];
+  defaultValue?: string;
+};
+export declare type AriaAttributesMap = Record<string, AriaAttrDependency>;
+/**
+ * Maps component attributes/properties to aria-XXX attributes on an inner native element.
+ * Observes attribute changes on host and updates the target element accordingly.
+ */
+export declare class AriaAttributesValueMapper extends MutationObserverSlimmer {
+  private readonly targetGetter;
+  private readonly ariaMap;
+  /**
+   * Component lifecycle - [componentDidLoad]
+   */
+  componentDidLoad(): void;
+  /**
+   * Run mapping after each component render to ensure refs assigned and
+   * attributes/properties are up-to-date. This guarantees the mapper runs
+   * even when attribute changes are observed before the inner target ref
+   * is available.
+   */
+  componentDidRender(): void;
+  /**
+   * The constructor initializes a class instance with a targetGetter function and an ariaMap.
+   *
+   * @param {() => HTMLElement} targetGetter - a function that returns the target element to set aria attributes on
+   * @param {AriaAttributesMap} ariaMap - a map where the key is the aria attribute to set on the target element, and the value is an object that defines the dependencies (attributes/properties on host to check for value) and an optional default value
+   */
+  constructor(targetGetter: () => HTMLElement, ariaMap: AriaAttributesMap);
+  /**
+   * The `handleMutations` function processes an array of `MutationRecord` objects to determine which attributes have changed and then calls the `performMapping` function to update the corresponding aria attributes on the target element. It collects the names of the changed attributes into a set and passes it to the `performMapping` function, which uses this information to decide which aria attributes need to be updated based on their defined dependencies.
+   *
+   * @param {MutationRecord[]} mutations - an array of MutationRecord objects that represent the changes observed by the MutationObserver. Each MutationRecord contains information about the type of mutation, the target element that was mutated, and any relevant attribute names if the mutation was an attribute change.
+   */
+  private handleMutations;
+  /**
+   * The `performMapping` function updates the aria attributes on the target element based on the defined dependencies in the `ariaMap`. It checks which attributes have changed (if provided) and only updates the aria attributes that depend on those changed attributes. For each aria attribute defined in the `ariaMap`, it looks for the first non-empty value among its dependencies (checking both attributes and properties on the host element) and sets that as the value of the aria attribute on the target element. If all dependencies are empty or undefined, it uses the default value specified in the `ariaMap`. The function also includes error handling when setting attributes on the target element.
+   *
+   * @param {Set<string>} changedAttrs - a set of attribute names that have changed on the host element
+   */
+  private performMapping;
+}

package/dist/types/helpers/slimmers/mutation-observer/test/aria-attributes-value-mapper.test.d.ts

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

package/dist/types/helpers/slimmers/position-calculation/base-position-calculation-strategy.d.ts

@@ -6,6 +6,15 @@ import { ElementAppenderShowConfig } from '../../ui/element-appender';
  */
 export declare abstract class BasePositionCalculationStrategy extends VegaSlimmer {
   abstract showConfig: ElementAppenderShowConfig;
+  /**
+   * Whether the controller should adjust/recompute position at this time.
+   *
+   * This hook allows strategies to avoid unnecessary work (for example, on scroll) by deciding
+   * whether a re-position is required.
+   *
+   * @returns {boolean} True when the controller should proceed with width/height/position adjustments.
+   */
+  shouldAdjustPosition(): boolean;
   /**
    * Get the position box.
    *
@@ -15,6 +24,54 @@ export declare abstract class BasePositionCalculationStrategy extends VegaSlimme
    * returns an ElementPositionBox.
    */
   protected getPositionBox(placement?: PlacementType[], alignment?: PositionAlignmentType[]): ElementPositionBox;
+  /**
+   * Whether the alignment space is enough
+   *
+   * @param {ElementScrollDimension} containerBox - The bounding box of the container element.
+   * @param {ElementBoundBox} targetBox - The position of the target element.
+   * @param {ElementBoundBox} elementBox - The box of the element that we're trying to position.
+   * @param {PlacementType} placement - The placement of the element relative to the target.
+   * @param {PlacementType} alignment - The alignment of the element relative to the target.
+   * @returns {boolean} return true if it has enough space, otherwise false
+   */
+  protected hasEnoughAlignmentSpace(containerBox: ElementScrollDimension, targetBox: ElementBoundBox, elementBox: ElementBoundBox, placement: PlacementType, alignment: PositionAlignmentType): boolean;
+  /**
+   * Calculate the left position of the element
+   *
+   * @param {ElementBoundBox} elementBox - The position box of the element.
+   * @param {ElementBoundBox} targetBox - The position box of the target element that is attached to.
+   * @param {PlacementType} placement - The placement of the element.
+   * @param {PositionAlignmentType} alignment - The alignment of the element
+   * @returns {number} The left position of the element.
+   */
+  protected calculateLeft(elementBox: ElementBoundBox, targetBox: ElementBoundBox, placement: PlacementType, alignment: PositionAlignmentType): number;
+  /**
+   * Calculate the top position of the element
+   *
+   * @param {ElementBoundBox} elementBox - The position box of the element.
+   * @param {ElementBoundBox} targetBox - The position box of the target element that is attached to.
+   * @param {PlacementType} placement - The placement of the element.
+   * @param {PositionAlignmentType} alignment - The alignment of the element
+   * @returns {number} the top position of the element.
+   */
+  protected calculateTop(elementBox: ElementBoundBox, targetBox: ElementBoundBox, placement: PlacementType, alignment: PositionAlignmentType): number;
+  /**
+   * It returns acceptable alignments.
+   *
+   * @returns {PositionAlignmentType[]} acceptable alignments
+   */
+  protected getAlignments(): PositionAlignmentType[];
+  /**
+   * It takes a list of placements and returns the first placement that has enough space to place the
+   * element
+   *
+   * @param {ElementScrollDimension} containerBox - The box of the container element.
+   * @param {ElementBoundBox} elementBox - The box of the element to be placed.
+   * @param {ElementBoundBox} targetBox - The box of the target element.
+   * @param {PlacementType[]} placements - The placements that we want to try.
+   * @returns {PlacementType} A function that takes in a containerBox, elementBox, targetBox, placements, and element.
+   */
+  protected getSuitablePlacement(containerBox: ElementScrollDimension, elementBox: ElementBoundBox, targetBox: ElementBoundBox, placements: PlacementType[]): PlacementType;
   /**
    * "Get the width, height, and top position of an element."
    *
@@ -37,12 +94,6 @@ export declare abstract class BasePositionCalculationStrategy extends VegaSlimme
    * @returns {PlacementType[]} ordered placements.
    */
   private getPlacements;
-  /**
-   * It returns acceptable alignments.
-   *
-   * @returns {PositionAlignmentType[]} acceptable alignments
-   */
-  private getAlignments;
   /**
    * It takes a placement, a target box, and a element box, and returns an element box
    *
@@ -60,37 +111,6 @@ export declare abstract class BasePositionCalculationStrategy extends VegaSlimme
    * @returns {TranslocationType} A translocation object with X and Y properties.
    */
   private getTranslocationBox;
-  /**
-   * Calculate the left position of the element
-   *
-   * @param {ElementBoundBox} elementBox - The position box of the element.
-   * @param {ElementBoundBox} targetBox - The position box of the target element that is attached to.
-   * @param {PlacementType} placement - The placement of the element.
-   * @param {PositionAlignmentType} alignment - The alignment of the element
-   * @returns {number} The left position of the element.
-   */
-  private calculateLeft;
-  /**
-   * Calculate the top position of the element
-   *
-   * @param {ElementBoundBox} elementBox - The position box of the element.
-   * @param {ElementBoundBox} targetBox - The position box of the target element that is attached to.
-   * @param {PlacementType} placement - The placement of the element.
-   * @param {PositionAlignmentType} alignment - The alignment of the element
-   * @returns {number} the top position of the element.
-   */
-  private calculateTop;
-  /**
-   * It takes a list of placements and returns the first placement that has enough space to place the
-   * element
-   *
-   * @param {ElementScrollDimension} containerBox - The box of the container element.
-   * @param {ElementBoundBox} elementBox - The box of the element to be placed.
-   * @param {ElementBoundBox} targetBox - The box of the target element.
-   * @param {PlacementType[]} placements - The placements that we want to try.
-   * @returns {PlacementType} A function that takes in a containerBox, elementBox, targetBox, placements, and element.
-   */
-  private getSuitablePlacement;
   /**
    * It takes a list of alignments and returns the suitable one that has enough space to fit the element
    *
@@ -102,17 +122,6 @@ export declare abstract class BasePositionCalculationStrategy extends VegaSlimme
    * @returns {PositionAlignmentType} the alignment that is suitable for the element.
    */
   private getSuitableAlignment;
-  /**
-   * Whether the alignment space is enough
-   *
-   * @param {ElementScrollDimension} containerBox - The bounding box of the container element.
-   * @param {ElementBoundBox} targetBox - The position of the target element.
-   * @param {ElementBoundBox} elementBox - The box of the element that we're trying to position.
-   * @param {PlacementType} placement - The placement of the element relative to the target.
-   * @param {PlacementType} alignment - The alignment of the element relative to the target.
-   * @returns {boolean} return true if it has enough space, otherwise false
-   */
-  private hasEnoughAlignmentSpace;
   /**
    * If the placement is top or left, then the target's top or left position must be greater than or
    * equal to the element's height or width. If the placement is bottom or right, then the container's

package/dist/types/helpers/slimmers/position-calculation/position-calculation-controller.d.ts

@@ -11,6 +11,11 @@ export declare class PositionCalculationController extends VegaSlimmer {
   protected readonly bodyPositionStrategy: BodyPositionCalculationStrategy;
   protected readonly screenPositionStrategy: ScreenPositionCalculationStrategy;
   private positionStrategy;
+  /**
+   * Clears any pending screen-position scroll animation frame callback.
+   * Call this when the appendable is hidden/destroyed.
+   */
+  clearScreenPositionScrollFrame(): void;
   /**
    * Sets the calculate postion strategy.
    */

package/dist/types/helpers/slimmers/position-calculation/screen-position-calculation-strategy.d.ts

@@ -1,5 +1,5 @@
 import { ElementAppenderShowConfig } from '../../ui/element-appender';
-import { ElementBoundBox, ElementPositionBox, ElementScrollDimension } from '../../../types/ui.type';
+import { ElementBoundBox, ElementPositionBox, ElementScrollDimension, PlacementType, PositionAlignmentType } from '../../../types/ui.type';
 import { BasePositionCalculationStrategy } from './base-position-calculation-strategy';
 /**
  * calculate position by screen container
@@ -7,6 +7,23 @@ import { BasePositionCalculationStrategy } from './base-position-calculation-str
 export declare class ScreenPositionCalculationStrategy extends BasePositionCalculationStrategy {
   showConfig: ElementAppenderShowConfig;
   private previousPositionBox;
+  private previousTargetRect;
+  private scrollFrameRequestId;
+  private usePreviousPlacement;
+  private readonly scrollPositionUpdateStrategy;
+  /**
+   * For screen-positioned appendable we may get a lot of scroll events.
+   * This hook throttles the check with requestAnimationFrame and only allows an adjust when
+   * the strategy determines we should update.
+   *
+   * @returns {boolean} True when controller should perform a position adjustment.
+   */
+  shouldAdjustPosition(): boolean;
+  /**
+   * Clears any pending scroll animation frame callback.
+   * Call this when popover is hidden/destroyed to avoid leaks and stale callbacks.
+   */
+  clearScrollFrame(): void;
   /**
    * Get the position of the element in the container according to the target element and the placement
    * If give a translocation, it will apply the translocation to the result.
@@ -31,4 +48,27 @@ export declare class ScreenPositionCalculationStrategy extends BasePositionCalcu
    * @returns {ElementScrollDimension} An object with two properties: width and height.
    */
   protected getElementScrollDimension(): ElementScrollDimension;
+  /**
+   * Whether the alignment space is enough
+   *
+   * @param {ElementScrollDimension} containerBox - The bounding box of the container element.
+   * @param {ElementBoundBox} targetBox - The position of the target element.
+   * @param {ElementBoundBox} elementBox - The box of the element that we're trying to position.
+   * @param {PlacementType} placement - The placement of the element relative to the target.
+   * @param {PlacementType} alignment - The alignment of the element relative to the target.
+   * @returns {boolean} return true if it has enough space, otherwise false
+   */
+  protected hasEnoughAlignmentSpace(containerBox: ElementScrollDimension, targetBox: ElementBoundBox, elementBox: ElementBoundBox, placement: PlacementType, alignment: PositionAlignmentType): boolean;
+  /**
+   * Screen-specific suitable placement selection.
+   * Tries to find a placement that has enough alignment space within the viewport first,
+   * otherwise falls back to the base strategy.
+   *
+   * @param {ElementScrollDimension} containerBox - The bounding box of the container.
+   * @param {ElementBoundBox} elementBox - The box of the element to place.
+   * @param {ElementBoundBox} targetBox - The box of the target element.
+   * @param {PlacementType[]} placements - Ordered list of placements to try.
+   * @returns {PlacementType} The chosen placement.
+   */
+  protected getSuitablePlacement(containerBox: ElementScrollDimension, elementBox: ElementBoundBox, targetBox: ElementBoundBox, placements: PlacementType[]): PlacementType;
 }

package/dist/types/helpers/slimmers/position-calculation/screen-scroll-position-update.d.ts

@@ -0,0 +1,39 @@
+export declare type ScrollPositionUpdateDecision = {
+  shouldUpdate: boolean;
+};
+export declare type ScrollPositionUpdateStrategyContext = {
+  currentTargetRect: DOMRect;
+  appendableRect: DOMRect;
+  previousTargetRect: DOMRect;
+  viewportWidth: number;
+  viewportHeight: number;
+};
+/**
+ * Updates position on scroll When the target rect changes, we recompute placement/alignment.
+ */
+export declare class ScreenScrollPositionUpdate {
+  private viewportWidth;
+  private viewportHeight;
+  /**
+   * Determines whether the appendable element's position should update on scroll.
+   *
+   * @param {ScrollPositionUpdateStrategyContext} context - Current/previous rectangles plus viewport size.
+   * @returns {ScrollPositionUpdateDecision} Decision that indicates whether to recompute position.
+   */
+  shouldUpdatePosition(context: ScrollPositionUpdateStrategyContext): ScrollPositionUpdateDecision;
+  /**
+   * Whether the rect is fully within the viewport bounds.
+   *
+   * @param {DOMRect} rect - The DOMRect to check.
+   * @returns {boolean} True when rect is fully within the viewport.
+   */
+  private isRectEntirelyWithinViewport;
+  /**
+   * Whether the element is fully outside the viewport.
+   * If true, the rect has "disappeared" from the viewport.
+   *
+   * @param {DOMRect} rect - The DOMRect to check.
+   * @returns {boolean} True when rect is completely outside viewport bounds.
+   */
+  private isRectOutsideViewport;
+}

package/dist/types/helpers/ui/element-appender.d.ts

@@ -41,7 +41,6 @@ export declare class ElementAppender {
   private showConfigCallbackTarget;
   private showConfig;
   private container;
-  private previousTargetRect;
   /**
    * The `constructor` function is used to initialize the `showConfigCallback` and
    * `showConfigCallbackTarget` properties of the class.

package/dist/types/index.d.ts

@@ -4,3 +4,5 @@ export * from './constants/public-api';
 export * from './helpers/public-api';
 export * from './types/public-api';
 export * from './helpers/validator/public-rules';
+export { VegaRTEContent } from './components/vega-rich-text-editor/dto/content-state';
+export * from './components/vega-rich-text-editor/public-api';

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

@@ -0,0 +1,3 @@
+export { tokenize } from './tokenizer';
+export { getLanguageGrammar } from './languages/language-registry';
+export type { SyntaxToken, Grammar, GrammarPattern, GrammarEntry } from './types';

package/dist/types/polyfill/prism/languages/css.d.ts

@@ -0,0 +1,6 @@
+import { Grammar } from '../types';
+/**
+ * Grammar definition for CSS syntax highlighting.
+ * Handles selectors, properties, values, at-rules, comments, strings, and other CSS constructs.
+ */
+export declare const cssGrammar: Grammar;

package/dist/types/polyfill/prism/languages/javascript.d.ts

@@ -0,0 +1,7 @@
+import { Grammar } from '../types';
+/**
+ * Grammar definition for JavaScript syntax highlighting.
+ * Handles keywords, operators, strings, template literals, numbers,
+ * regex literals, comments, functions, classes, and other JS constructs.
+ */
+export declare const javascriptGrammar: Grammar;

package/dist/types/polyfill/prism/languages/jsx.d.ts

@@ -0,0 +1,7 @@
+import { Grammar } from '../types';
+/**
+ * Grammar definition for JSX syntax highlighting.
+ * Extends JavaScript grammar with JSX tag syntax for React components,
+ * including self-closing tags, expressions in braces, and embedded markup attributes.
+ */
+export declare const jsxGrammar: Grammar;

package/dist/types/polyfill/prism/languages/language-registry.d.ts

@@ -0,0 +1,8 @@
+import { Grammar } from '../types';
+/**
+ * Retrieve the grammar for a given language identifier.
+ *
+ * @param {string} language - The language identifier (e.g., 'js', 'css', 'html', 'ts', 'jsx', 'tsx').
+ * @returns {Grammar | undefined} The grammar definition, or undefined if the language is not registered.
+ */
+export declare function getLanguageGrammar(language: string): Grammar | undefined;

package/dist/types/polyfill/prism/languages/markup.d.ts

@@ -0,0 +1,6 @@
+import { Grammar } from '../types';
+/**
+ * Grammar definition for HTML/Markup syntax highlighting.
+ * Handles tags, attributes, comments, doctypes, CDATA, entities, and embedded content.
+ */
+export declare const markupGrammar: Grammar;

package/dist/types/polyfill/prism/languages/tsx.d.ts

@@ -0,0 +1,7 @@
+import { Grammar } from '../types';
+/**
+ * Grammar definition for TSX (TypeScript + JSX) syntax highlighting.
+ * Merges TypeScript and JSX grammars, supporting both type annotations
+ * and JSX tag syntax in the same file.
+ */
+export declare const tsxGrammar: Grammar;

package/dist/types/polyfill/prism/languages/typescript.d.ts

@@ -0,0 +1,2 @@
+import { Grammar } from '../types';
+export declare const typescriptGrammar: Grammar;

package/dist/types/polyfill/prism/test/css.test.d.ts

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

package/dist/types/polyfill/prism/test/javascript.test.d.ts

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

package/dist/types/polyfill/prism/test/jsx.test.d.ts

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

package/dist/types/polyfill/prism/test/language-registry.test.d.ts

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

package/dist/types/polyfill/prism/test/markup.test.d.ts

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

package/dist/types/polyfill/prism/test/test-utils.d.ts

@@ -0,0 +1,10 @@
+import { SyntaxToken } from '../types';
+/**
+ * Recursively find all tokens of a given type within a token array.
+ * Traverses nested token content arrays to find deeply nested tokens.
+ *
+ * @param {(string | SyntaxToken)[]} tokens - The token array to search.
+ * @param {string} type - The token type to filter by.
+ * @returns {SyntaxToken[]} All tokens matching the specified type.
+ */
+export declare const findTokensByType: (tokens: (string | SyntaxToken)[], type: string) => SyntaxToken[];

package/dist/types/polyfill/prism/test/tokenizer.test.d.ts

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

package/dist/types/polyfill/prism/test/tsx.test.d.ts

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

package/dist/types/polyfill/prism/test/typescript.test.d.ts

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

package/dist/types/polyfill/prism/tokenizer.d.ts

@@ -0,0 +1,17 @@
+import { Grammar, SyntaxToken } from './types';
+/**
+ * Core tokenizer that converts source code into syntax tokens based on a grammar definition.
+ * This is a local replacement for Prism tokenize.
+ *
+ * The tokenizer works by:
+ * 1. Pre-processing greedy patterns to claim their matched regions first
+ * 2. Iterating through all grammar rules in order
+ * 3. Finding regex matches in the source text
+ * 4. Splitting the text into matched (typed) and unmatched (plain) segments
+ * 5. Recursively tokenizing nested content when an `inside` grammar is specified
+ *
+ * @param {string} code - The source code string to tokenize.
+ * @param {Grammar} grammar - The grammar rules to apply for tokenization.
+ * @returns {(string | SyntaxToken)[]} An array of plain strings and syntax tokens.
+ */
+export declare function tokenize(code: string, grammar: Grammar): (string | SyntaxToken)[];

package/dist/types/polyfill/prism/types.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Represents a token produced by the syntax highlighting tokenizer.
+ * A token has a type (e.g. 'keyword', 'string', 'comment') and content
+ * which can be a string, a single nested token, or an array of mixed strings and tokens.
+ */
+export interface SyntaxToken {
+  type: string;
+  content: string | SyntaxToken | (string | SyntaxToken)[];
+}
+/**
+ * A grammar rule pattern used for tokenizing source code.
+ * Each pattern has a regex to match and an optional `inside` grammar for nested tokenization.
+ */
+export interface GrammarPattern {
+  pattern: RegExp;
+  lookbehind?: boolean;
+  greedy?: boolean;
+  inside?: Grammar;
+}
+/**
+ * A grammar is a map of token type names to their pattern definitions.
+ * Each entry can be a single pattern, an array of patterns, or a nested grammar reference.
+ */
+export declare type GrammarEntry = GrammarPattern | GrammarPattern[];
+export declare type Grammar = Record<string, GrammarEntry>;