@myrmidon/gve-core 3.0.3 → 5.0.1

package/index.d.ts

@@ -1,5 +1,1543 @@
+import { MatDialogConfig, MatDialogRef, MatDialog } from '@angular/material/dialog';
+import * as _angular_core from '@angular/core';
+import { OnInit, OnDestroy, ElementRef, AfterViewInit } from '@angular/core';
+import { FormControl, FormGroup, FormBuilder } from '@angular/forms';
+import { GveAnimationTimeline, GveAnimationTween, TweenType, CharNode, Feature, CharChainOperation, OperationFeature, LabeledId, FeatureSetPolicy, SnapshotBase, OperationSource, OperationType, SnapshotViewComponent, Snapshot, SnapshotViewData, GveVisualEvent, SnapshotViewRenderEvent } from '@myrmidon/gve-snapshot-view';
+import { DialogService } from '@myrmidon/ngx-mat-tools';
+import { HttpClient } from '@angular/common/http';
+import { Observable } from 'rxjs';
+import { ErrorService, EnvService } from '@myrmidon/ngx-tools';
+import { Clipboard } from '@angular/cdk/clipboard';
+import { MatSnackBar } from '@angular/material/snack-bar';
+
 /**
- * Generated bundle index. Do not edit.
+ * API call result wrapper.
  */
-/// <amd-module name="@myrmidon/gve-core" />
-export * from './public-api';
+interface ResultWrapper<T> {
+    result?: T;
+    error?: string;
+}
+/**
+ * PayloadMatDialogConfig is a MatDialogConfig with a payload, used
+ * to pass data of type T to a dialog.
+ */
+interface PayloadMatDialogConfig<T> extends MatDialogConfig {
+    payload?: T;
+}
+
+/**
+ * 🔑 `gve-animation-timeline`
+ *
+ * A component to edit an animation timeline.
+ * Used by the `gve-animation-timeline-set` component.
+ *
+ * - ▶️ `timeline` (`GveAnimationTimeline`): the animation timeline to edit.
+ * - ▶️ `elementIds` (`string[]`): the IDs of the elements that can be selected
+ * by the tween.
+ * - ▶️ `tags` (`string[]`): the tags that can be used by the timeline.
+ * - 🔥 `timelineChange` (`GveAnimationTimeline`): emitted when the timeline
+ * is changed.
+ * - 🔥 `timelineCancel` (`void`): emitted when the timeline editing is canceled.
+ */
+declare class AnimationTimelineComponent {
+    /**
+     * The animation timeline to edit.
+     */
+    readonly timeline: _angular_core.ModelSignal<GveAnimationTimeline | undefined>;
+    /**
+     * The IDs of the elements that can be selected by the tween.
+     * This list is used to allow the user to select an element from a dropdown.
+     */
+    readonly elementIds: _angular_core.InputSignal<string[] | undefined>;
+    /**
+     * The tags that can be used by the timeline.
+     */
+    readonly tags: _angular_core.InputSignal<string[]>;
+    /**
+     * Emitted when the timeline is changed.
+     */
+    readonly timelineChange: _angular_core.OutputEmitterRef<GveAnimationTimeline>;
+    /**
+     * Emitted when the timeline editing is canceled.
+     */
+    readonly timelineCancel: _angular_core.OutputEmitterRef<void>;
+    readonly editedTweenIndex: _angular_core.WritableSignal<number>;
+    readonly editedTween: _angular_core.WritableSignal<GveAnimationTween | undefined>;
+    tag: FormControl<string>;
+    tweens: FormControl<GveAnimationTween[]>;
+    vars: FormControl<string | null>;
+    form: FormGroup;
+    constructor(formBuilder: FormBuilder);
+    private jsonValidator;
+    private updateForm;
+    addTween(): void;
+    editTween(index: number): void;
+    deleteTween(index: number): void;
+    closeTween(): void;
+    saveTween(tween?: GveAnimationTween): void;
+    moveTweenUp(index: number): void;
+    moveTweenDown(index: number): void;
+    private getTimeline;
+    close(): void;
+    save(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AnimationTimelineComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AnimationTimelineComponent, "gve-animation-timeline", never, { "timeline": { "alias": "timeline"; "required": false; "isSignal": true; }; "elementIds": { "alias": "elementIds"; "required": false; "isSignal": true; }; "tags": { "alias": "tags"; "required": false; "isSignal": true; }; }, { "timeline": "timelineChange"; "timelineChange": "timelineChange"; "timelineCancel": "timelineCancel"; }, never, never, true, never>;
+}
+
+/**
+ * 🔑 `gve-animation-timeline-set`
+ *
+ * A component to edit a set of animation timelines.
+ * Used by the `gve-snapshot-editor` component.
+ *
+ * - ▶️ `timelines` (`GveAnimationTimeline[]`): the animation timelines to edit.
+ * - ▶️ `elementIds` (`string[]`): the IDs of the elements that can be selected by the tween.
+ * - ▶️ `tags` (`string[]`): the tags that can be used by the timeline.
+ * - 🔥 `timelinesChange` (`GveAnimationTimeline[]`): emitted when the timelines are changed.
+ * - 🔥 `timelinesCancel` (`void`): emitted when the timeline editing is canceled.
+ */
+declare class AnimationTimelineSetComponent {
+    private _dialogService;
+    /**
+     * The animation timelines to edit.
+     */
+    readonly timelines: _angular_core.ModelSignal<GveAnimationTimeline[]>;
+    /**
+     * The IDs of the elements that can be selected by the tween.
+     * This list is used to allow the user to select an element from a dropdown.
+     */
+    readonly elementIds: _angular_core.InputSignal<string[] | undefined>;
+    /**
+     * The tags that can be used by the timeline.
+     */
+    readonly tags: _angular_core.InputSignal<string[]>;
+    /**
+     * Emitted when the timeline editing is canceled.
+     */
+    readonly timelinesCancel: _angular_core.OutputEmitterRef<void>;
+    readonly editedTimeline: _angular_core.WritableSignal<GveAnimationTimeline | undefined>;
+    readonly editedIndex: _angular_core.WritableSignal<number>;
+    constructor(_dialogService: DialogService);
+    closeTimeline(): void;
+    newTimeline(): void;
+    editTimeline(index: number): void;
+    onTimelineChange(timeline: GveAnimationTimeline): void;
+    deleteTimeline(index: number): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AnimationTimelineSetComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AnimationTimelineSetComponent, "gve-animation-timeline-set", never, { "timelines": { "alias": "timelines"; "required": false; "isSignal": true; }; "elementIds": { "alias": "elementIds"; "required": false; "isSignal": true; }; "tags": { "alias": "tags"; "required": false; "isSignal": true; }; }, { "timelines": "timelinesChange"; "timelinesCancel": "timelinesCancel"; }, never, never, true, never>;
+}
+
+/**
+ * 🔑 `gve-animation-tween`
+ *
+ * A component to edit an animation tween.
+ * Used by the `gve-animation-timeline` component.
+ *
+ * - ▶️ `tween` (`GveAnimationTween`): the tween to edit.
+ * - ▶️ `elementIds` (`string[]`): the IDs of the elements that can be selected by the tween.
+ * - 🔥 `tweenChange` (`GveAnimationTween`): emitted when the tween is changed.
+ * - 🔥 `tweenCancel` (`void`): emitted when the user cancels the edit.
+ */
+declare class AnimationTweenComponent implements OnInit, OnDestroy {
+    private _sub?;
+    /**
+     * The tween to edit.
+     */
+    readonly tween: _angular_core.ModelSignal<GveAnimationTween | undefined>;
+    /**
+     * The IDs of the elements that can be selected by the tween.
+     * This list is used to allow the user to select an element from a dropdown.
+     */
+    readonly elementIds: _angular_core.InputSignal<string[] | undefined>;
+    /**
+     * Emitted when the user cancels the edit.
+     */
+    readonly tweenCancel: _angular_core.OutputEmitterRef<void>;
+    readonly types: string[];
+    label: FormControl<string>;
+    note: FormControl<string | null>;
+    type: FormControl<TweenType>;
+    selector: FormControl<string>;
+    vars: FormControl<string>;
+    vars2: FormControl<string | null>;
+    position: FormControl<string | null>;
+    form: FormGroup;
+    elementId: FormControl<string | null>;
+    constructor(formBuilder: FormBuilder);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    onVarsChange(vars: string): void;
+    onVars2Change(vars: string): void;
+    close(): void;
+    private jsonValidator;
+    private updateForm;
+    private getTween;
+    openUrl(url: string): void;
+    save(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<AnimationTweenComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<AnimationTweenComponent, "gve-animation-tween", never, { "tween": { "alias": "tween"; "required": false; "isSignal": true; }; "elementIds": { "alias": "elementIds"; "required": false; "isSignal": true; }; }, { "tween": "tweenChange"; "tweenCancel": "tweenCancel"; }, never, never, true, never>;
+}
+
+/**
+ * A single character from a base text.
+ */
+interface BaseTextChar {
+    id: number;
+    value: string;
+    label: string;
+    color: string;
+    oldColor?: string;
+    borderColor: string;
+    oldBorderColor?: string;
+    emSize: number;
+}
+/**
+ * Event emitted by the base text character component when a character
+ * is clicked.
+ */
+interface BaseTextCharEvent {
+    char: BaseTextChar;
+    event: MouseEvent;
+}
+/**
+ * 🔑 `gve-base-text-char`
+ *
+ * A component that displays a single character from a base text.
+ * Used by `gve-base-text-view`.
+ */
+declare class BaseTextCharComponent {
+    /**
+     * The character to display.
+     */
+    readonly char: _angular_core.InputSignal<BaseTextChar | undefined>;
+    /**
+     * Emitted when the character is clicked.
+     */
+    readonly charPick: _angular_core.OutputEmitterRef<BaseTextCharEvent>;
+    readonly defaultColor = "#D8D8D8";
+    readonly defaultBorderColor = "#D8D8D8";
+    readonly defaultEmSize = 1.5;
+    onCharClick(event: MouseEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseTextCharComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BaseTextCharComponent, "gve-base-text-char", never, { "char": { "alias": "char"; "required": false; "isSignal": true; }; }, { "charPick": "charPick"; }, never, never, true, never>;
+}
+
+/**
+ * A range in the base text.
+ */
+interface VarBaseTextRange {
+    at: number;
+    run: number;
+}
+/**
+ * 🔑 `gve-base-text-view`
+ *
+ * A component to display a selectable base text. Its input is either a string or an
+ * array of `CharNode`'s.
+ * Used by the chain result view component and the base text editor component.
+ *
+ * - ▶️ `defaultColor` (`string`): the default color for the text.
+ * - ▶️ `colorCallback` (callback): an optional callback to get the color of a
+ * character node.
+ * - ▶️ `defaultBorderColor` (`string`): the default border color for the text.
+ * - ▶️ `borderColorCallback` (callback): an optional callback to get the border color
+ * of a character node.
+ * - ▶️ `selectionColor` (`string`): the color for the selected text.
+ * - ▶️ `hasLineNumber` (`boolean`): true if line numbers should be displayed next
+ * to each line.
+ * - ▶️ `text` (`string` | `CharNode[]`): the text to display.
+ * - 🔥 `charPick` (`BaseTextCharEvent`): emitted when a character is picked.
+ * - 🔥 `rangePick` (`VarBaseTextRange`): emitted when a range is picked.
+ */
+declare class BaseTextViewComponent {
+    private _lastSelectedChar?;
+    /**
+     * The default color for the text.
+     */
+    readonly defaultColor: _angular_core.InputSignal<string>;
+    /**
+     * The default border color for the text.
+     */
+    readonly defaultBorderColor: _angular_core.InputSignal<string>;
+    /**
+     * The color for the selected text.
+     */
+    readonly selectionColor: _angular_core.InputSignal<string>;
+    /**
+     * True if line numbers should be displayed next to each line.
+     */
+    readonly hasLineNumber: _angular_core.InputSignal<boolean>;
+    /**
+     * The text to display.
+     */
+    readonly text: _angular_core.InputSignal<CharNode[]>;
+    /**
+     * An optional callback to get the color of a character node.
+     * Return null to use the default color.
+     */
+    readonly colorCallback: _angular_core.InputSignal<((node: CharNode) => string | null) | undefined>;
+    /**
+     * An optional callback to get the color of a character node.
+     * Return null to use the default color.
+     */
+    readonly borderColorCallback: _angular_core.InputSignal<((node: CharNode) => string | null) | undefined>;
+    /**
+     * Emitted when a character is picked.
+     */
+    readonly charPick: _angular_core.OutputEmitterRef<BaseTextCharEvent>;
+    /**
+     * Emitted when a range is picked. This is preceded by a character pick event.
+     * The range is defined by the starting character and the number of characters.
+     * The range is inclusive.
+     */
+    readonly rangePick: _angular_core.OutputEmitterRef<VarBaseTextRange>;
+    readonly lines: _angular_core.WritableSignal<BaseTextChar[][]>;
+    constructor();
+    private buildLines;
+    private resetColors;
+    onCharPick(event: BaseTextCharEvent): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseTextViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BaseTextViewComponent, "gve-base-text-view", never, { "defaultColor": { "alias": "defaultColor"; "required": false; "isSignal": true; }; "defaultBorderColor": { "alias": "defaultBorderColor"; "required": false; "isSignal": true; }; "selectionColor": { "alias": "selectionColor"; "required": false; "isSignal": true; }; "hasLineNumber": { "alias": "hasLineNumber"; "required": false; "isSignal": true; }; "text": { "alias": "text"; "required": false; "isSignal": true; }; "colorCallback": { "alias": "colorCallback"; "required": false; "isSignal": true; }; "borderColorCallback": { "alias": "borderColorCallback"; "required": false; "isSignal": true; }; }, { "charPick": "charPick"; "rangePick": "rangePick"; }, never, never, true, never>;
+}
+
+/**
+ * 🔑 `gve-base-text-editor`
+ *
+ * Editor for snapshot's base text. This can receive a string or an array
+ * of `CharNode` objects, and lets the user edit the text, character by
+ * character, optionally also setting its features.
+ *
+ * Used by the `gve-snapshot-editor` component.
+ */
+declare class BaseTextEditorComponent {
+    private _dialogService;
+    /**
+     * The text to edit. In input this can be a string, an array of `CharNode`
+     * objects, or undefined. In output this will be an array of `CharNode`
+     * objects.
+     */
+    readonly text: _angular_core.InputSignalWithTransform<CharNode[] | undefined, string | CharNode[] | undefined>;
+    /**
+     * Emitted for the edited text as an array of `CharNode`'s whenever it changes.
+     */
+    readonly textChange: _angular_core.OutputEmitterRef<CharNode[]>;
+    readonly selectedChar: _angular_core.WritableSignal<CharNode | undefined>;
+    readonly selectedCharLabel: _angular_core.WritableSignal<string | undefined>;
+    readonly textRange: _angular_core.WritableSignal<VarBaseTextRange | undefined>;
+    userText: FormControl<string>;
+    form: FormGroup;
+    constructor(formBuilder: FormBuilder, _dialogService: DialogService);
+    private resetSelectedChar;
+    onSelectedChar(event: BaseTextCharEvent): void;
+    onFeaturesChange(features: Feature[]): void;
+    onRangePick(range: VarBaseTextRange): void;
+    patchTextFromUser(): void;
+    setTextFromUser(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BaseTextEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BaseTextEditorComponent, "gve-base-text-editor", never, { "text": { "alias": "text"; "required": true; "isSignal": true; }; }, { "textChange": "textChange"; }, never, never, true, never>;
+}
+
+/**
+ * Execution step of a char-based chain operation.
+ */
+interface ChainOperationContextStep {
+    /**
+     * The operation that was executed.
+     */
+    operation: CharChainOperation;
+    /**
+     * The input version tag.
+     */
+    inputTag: string;
+    /**
+     * The output version tag.
+     */
+    outputTag: string;
+    /**
+     * The string synthetically representing the resulting text
+     * version.
+     */
+    result?: string;
+    /**
+     * The features emitted up to the executed operation.
+     * These are the features of the text as a whole, and
+     * those belonging to specific nodes, each keyed under
+     * a string built with `v` + output version tag + `_`
+     * + node ID (e.g. `v1_2` for node with ID 2 at version 1).
+     */
+    featureSet: {
+        features: OperationFeature[];
+        nodeFeatures: Record<string, OperationFeature[]>;
+    };
+    /**
+     * The reference node IDs of the operation which was
+     * executed.
+     */
+    refNodeIds: number[];
+}
+/**
+ * Result of execution of a char-based chain.
+ */
+interface CharChainResult {
+    /**
+     * The execution steps of the chain.
+     */
+    steps: ChainOperationContextStep[];
+    /**
+     * The chain dump, which is the text representation of the chain.
+     */
+    chainDump: string;
+    /**
+     * The list of all unique tags in the chain.
+     */
+    chainTags: string[];
+    /**
+     * The sets of nodes in their order, for each version tag.
+     * These nodes are collected by following the path defined
+     * by the set of links of each version tag; so each of the
+     * sets contains only the nodes used at that step to build
+     * the text version, with their features up to that stage.
+     */
+    taggedNodes: {
+        [key: string]: CharNode[];
+    };
+}
+/**
+ * The input and output tags of a char-based chain operation.
+ */
+interface ChainOperationTags {
+    inputTag: string;
+    outputTag: string;
+}
+/**
+ * The node of a character-based chain, used for diagnostic
+ * or demonstration purposes.
+ */
+interface CharChainNode {
+    id: number;
+    label: string;
+    data: string;
+    sourceTag?: string;
+}
+/**
+ * The link of a character-based chain, used for diagnostic
+ * or demonstration purposes.
+ */
+interface CharChainLink {
+    tag: string;
+    sourceId: number;
+    targetId: number;
+}
+/**
+ * The character-based chain, as resulting from running operations
+ * on a base text, used for diagnostic or demonstration purposes.
+ */
+interface CharChain {
+    nodes: CharChainNode[];
+    links: CharChainLink[];
+}
+/**
+ * Service to interact with the GVE API.
+ */
+declare class GveApiService {
+    private _http;
+    private _error;
+    private _env;
+    constructor(_http: HttpClient, _error: ErrorService, _env: EnvService);
+    /**
+     * Parse the specified text into operations. Each operation is a line
+     * of the text.
+     * @param text The text to parse.
+     * @returns The operations.
+     */
+    parseOperations(text: string): Observable<ResultWrapper<CharChainOperation[]>>;
+    /**
+     * Run operations on the specified text.
+     *
+     * @param text The base text.
+     * @param operations The operations to run.
+     * @returns Result wrapper.
+     */
+    runOperations(text: CharNode[], operations: CharChainOperation[]): Observable<ResultWrapper<CharChainResult>>;
+    /**
+     * Get the input and output tags for the given operations.
+     *
+     * @param operations The operations.
+     * @returns Result wrapper.
+     */
+    getTags(operations: CharChainOperation[]): Observable<ResultWrapper<string[]>>;
+    /**
+     * Get the chain corresponding to the operations run on the
+     * specified text. This is used for diagnostic or demonstration
+     * purposes.
+     *
+     * @param text The base text.
+     * @param operations The operations to run.
+     * @returns Result wrapper.
+     */
+    getChain(text: CharNode[], operations: CharChainOperation[]): Observable<ResultWrapper<CharChain>>;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GveApiService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GveApiService>;
+}
+
+/**
+ * 🔑 `gve-batch-operation-editor`
+ *
+ * A component to edit a batch of operations. This component can be used both in a dialog
+ * and as a standalone component.
+ *
+ * - ▶️ `preset` (`string`): the optional preset text to parse.
+ * - 🔥 `operationsChange` (`CharChainOperation[]`): event emitted when operations change.
+ */
+declare class BatchOperationEditorComponent implements OnInit {
+    private _api;
+    dialogRef?: MatDialogRef<BatchOperationEditorComponent> | undefined;
+    data?: PayloadMatDialogConfig<{
+        preset?: string;
+    }> | undefined;
+    readonly busy: _angular_core.WritableSignal<boolean>;
+    readonly parseError: _angular_core.WritableSignal<string | undefined>;
+    text: FormControl<string | null>;
+    form: FormGroup;
+    /**
+     * The preset text to parse if any. Usually you start with a blank
+     * text, but sometimes you might want to pre-set it.
+     */
+    readonly preset: _angular_core.InputSignal<string | undefined>;
+    /**
+     * Emitted when operations change.
+     */
+    readonly operationsChange: _angular_core.OutputEmitterRef<CharChainOperation[]>;
+    constructor(formBuilder: FormBuilder, _api: GveApiService, dialogRef?: MatDialogRef<BatchOperationEditorComponent> | undefined, data?: PayloadMatDialogConfig<{
+        preset?: string;
+    }> | undefined);
+    ngOnInit(): void;
+    parseOperations(text?: string): void;
+    close(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<BatchOperationEditorComponent, [null, null, { optional: true; }, { optional: true; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<BatchOperationEditorComponent, "gve-batch-operation-editor", never, { "preset": { "alias": "preset"; "required": false; "isSignal": true; }; }, { "operationsChange": "operationsChange"; }, never, never, true, never>;
+}
+
+/**
+ * Service to store and retrieve dynamic settings.
+ */
+declare class SettingsService {
+    private readonly _cache;
+    private readonly _subject;
+    /**
+     * Observable emitting the key of the setting that has changed.
+     */
+    get settingChange$(): Observable<string | null>;
+    /**
+     * Prefix to scope the keys. This prefix is used internally to scope the keys
+     * so that they cannot conflict with other keys in the local storage.
+     * The prefix is totally transparent to the user of the service, who should
+     * use the keys without the prefix.
+     */
+    keyPrefix?: string;
+    /**
+     * True to persist the settings in the local storage by default.
+     */
+    persistDefault: boolean;
+    /**
+     * Scopes the key by prefixing it with the keyPrefix if any.
+     *
+     * @param key The key to scope.
+     * @returns The scoped key.
+     */
+    private getScopedKey;
+    private isPersist;
+    /**
+     * Sets a setting's value.
+     *
+     * @param key The key.
+     * @param value The value.
+     * @param persist True to persist this setting in local storage.
+     */
+    set(key: string, value: any, persist?: boolean): void;
+    /**
+     * Set multiple settings at once from the specified settings object.
+     *
+     * @param settings The settings to set.
+     * @param persist True to persist these settings in local storage.
+     */
+    setFrom(settings: {
+        [key: string]: any;
+    } | undefined | null, persist?: boolean): void;
+    /**
+     * Get a setting's value of type T.
+     *
+     * @param key The key.
+     * @param defaultValue The default value to get when the setting
+     * is not found in the store.
+     * @returns The value.
+     */
+    get<T>(key: string, defaultValue?: any, persist?: boolean): T;
+    /**
+     * Check if a key exists in the store.
+     *
+     * @param key The key.
+     * @param persist True to check if the key exists in local storage.
+     * @returns True if the key exists in the store.
+     */
+    contains(key: string, persist?: boolean): boolean;
+    /**
+     * Get all the keys of the settings in the store.
+     *
+     * @param persist True to include keys from local storage.
+     * @returns The keys of the settings in the store.
+     */
+    getKeys(persist?: boolean): string[];
+    /**
+     * Remove a setting if present.
+     *
+     * @param key The key.
+     * @param persist True to remove the setting from local storage.
+     */
+    remove(key: string, persist?: boolean): void;
+    /**
+     * Clear all settings. Warning: this will remove all settings from the
+     * local storage if no key prefix is set.
+     *
+     * @param persist True to remove all settings from local storage.
+     */
+    clear(persist?: boolean): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SettingsService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<SettingsService>;
+}
+
+/**
+ * Features map. This is used for features from closed sets,
+ * and lists the possible values for each feature.
+ * The key is the feature name, and the value is an array of
+ * labeled IDs representing the allowed values for that feature.
+ */
+interface FeatureMap {
+    [key: string]: LabeledId[];
+}
+/**
+ * 🔑 `gve-feature-editor`
+ *
+ * Component for editing a single feature, whose model is a name=value
+ * pair, plus a set policy value which defines the desired behavior
+ * when adding that feature to a set.
+ * Used by `gve-feature-set-editor`.
+ *
+ * - ▶️ `feature` (`Feature`): the feature to edit.
+ * - ▶️ `featNames` (`LabeledId[]`): the list of feature names to display
+ * in the _name_ selection. This is used when you have a closed list of
+ * features. Each item in the list is an object with _id_ and _label_
+ * properties.
+ * - ▶️ `featValues` (`FeatureMap`): the feature values map. When
+ * specified and the user selects a feature name present in the map keys,
+ * the corresponding values will be used to populate the value selection.
+ * - 🔥 `featureChange` (`Feature`): emitted when feature has changed.
+ * - 🔥 `featureCancel`: emitted when the user cancels the feature editing.
+ */
+declare class FeatureEditorComponent implements OnInit, OnDestroy {
+    private _sub?;
+    private _frozen?;
+    nameControl?: ElementRef;
+    /**
+     * The list of feature names to display in the name selection.
+     * This is used when you have a closed list of features.
+     */
+    readonly featNames: _angular_core.InputSignal<LabeledId[] | undefined>;
+    /**
+     * The feature values map. When specified and the user selects a feature
+     * name present in the map keys, the corresponding values will be used
+     * to populate the value selection.
+     */
+    readonly featValues: _angular_core.InputSignal<FeatureMap | undefined>;
+    /**
+     * The feature to edit.
+     */
+    readonly feature: _angular_core.ModelSignal<Feature | OperationFeature | undefined>;
+    /**
+     * True if the feature is a variant operation feature, which has
+     * additional properties like negation, global, and short-lived.
+     */
+    readonly isVar: _angular_core.InputSignal<boolean>;
+    /**
+     * Event emitted when the user cancels the feature editing.
+     */
+    readonly featureCancel: _angular_core.OutputEmitterRef<void>;
+    readonly nameIds: _angular_core.WritableSignal<LabeledId[] | undefined>;
+    name: FormControl<string>;
+    value: FormControl<string>;
+    setPolicy: FormControl<FeatureSetPolicy>;
+    isNegated: FormControl<boolean>;
+    isGlobal: FormControl<boolean>;
+    isShortLived: FormControl<boolean>;
+    form: FormGroup;
+    constructor(formBuilder: FormBuilder);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private getLabeledIdsFor;
+    private updateForm;
+    cancel(): void;
+    save(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FeatureEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FeatureEditorComponent, "gve-feature-editor", never, { "featNames": { "alias": "featNames"; "required": false; "isSignal": true; }; "featValues": { "alias": "featValues"; "required": false; "isSignal": true; }; "feature": { "alias": "feature"; "required": false; "isSignal": true; }; "isVar": { "alias": "isVar"; "required": false; "isSignal": true; }; }, { "feature": "featureChange"; "featureCancel": "featureCancel"; }, never, never, true, never>;
+}
+
+/**
+ * Definitions for features, including names and values.
+ */
+interface FeatureDefinitions {
+    /**
+     * The list of feature names to display in the name selection.
+     * This is used when you have a closed list of features.
+     */
+    names?: LabeledId[];
+    /**
+     * The feature values map. When specified and the user selects a feature
+     * name present in the map keys, the corresponding values will be used
+     * to populate the value selection.
+     */
+    values?: FeatureMap;
+}
+/**
+ * 🔑 `gve-chain-operation-editor`
+ *
+ * A component for editing a variant generation operation.
+ * Used by the `gve-snapshot-editor` component.
+ * - ▶️ `operation` (`CharChainOperation`): the operation to edit.
+ * - ▶️ `snapshot` (`SnapshotBase`): the snapshot the operation refers to.
+ * - ▶️ `hidePreview` (`boolean`): whether to hide the preview request button.
+ * - 🔥 `operationChange` (`CharChainOperation`): emitted when the operation
+ * is changed.
+ * - 🔥 `operationPreview` (`CharChainOperation`): emitted when the operation
+ * preview is requested.
+ * - 🔥 `operationCancel` (`void`): emitted when operation editing is cancelled.
+ *
+ * The editor is composed of many sections:
+ * - **general**:
+ *  - ID: each operation has an ID, automatically assigned. This is not used in
+ * the context of the operation or of its transformations, but is provided as a
+ * reference.
+ *  - at and run: coordinates for the selection of the base text targeted by
+ * this operation. Check `idx` when `at` is index-based rather than ID-based.
+ *  - to and to-run: a second coordinate, used by some operations.
+ *  - value: the text value argument, for those operations requiring it.
+ *  - rank and group ID.
+ *  - input and output tags.
+ *  - features. These are metadata attached to this operation, and can be any
+ * type of name=value pairs.
+ * - **sources**: sources are a special type of metadata used when your text
+ * versions come from more than a single source. In this case, you can specify
+ * the source(s) for each operation, just like in a traditional apparatus you
+ * specify witnesses for each variant. Each source has an ID, a type, a
+ * probability rank (0=not specified, else 1-N), and an optional free text note.
+ * - **diplomatic**: SVG `g` code. The diplomatic section is the approximate
+ * diplomatic representation of the layout of the annotated text. It essentially
+ * consists in a freely editable SVG code, always grouped into a single root `g`
+ * element, encoding all the graphical traits representing this operation.
+ * The visual part of each operation can be placed everywhere on the snapshot,
+ * as specified by its coordinates.
+ * - **elements**: features of any of the SVG code elements having an ID.
+ * The elements section lists all the SVG elements having an `id` attribute in
+ * the SVG code of the diplomatic section. The ID allows you to attach
+ * any number of features (metadata modeled as name=value pairs) to each of
+ * these elements. Among these features, you may use `style` or `class` for
+ * renditional purposes, and any other name for your own metadata. Note that
+ * element IDs will be required also when dealing with animations. So, ensure
+ * to assign an ID to each element you want to animate.
+ * - **dp feats**: diplomatic features: these are features (metadata modeled
+ * as name=value pairs) for the diplomatic representation of this operation
+ * as a whole.
+ */
+declare class ChainOperationEditorComponent implements OnInit, OnDestroy {
+    private _clipboard;
+    private _settings;
+    private _dialogService;
+    private readonly _disposables;
+    private readonly _subs;
+    private readonly _nanoid;
+    private _editorModel?;
+    private _editor?;
+    /**
+     * The operation to edit.
+     */
+    readonly operation: _angular_core.ModelSignal<CharChainOperation | undefined>;
+    /**
+     * The snapshot the operation refers to.
+     */
+    readonly snapshot: _angular_core.InputSignal<SnapshotBase | undefined>;
+    /**
+     * Whether to hide the preview request button.
+     */
+    readonly hidePreview: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * Definitions for features, including names and values.
+     */
+    readonly featureDefs: _angular_core.InputSignal<FeatureDefinitions | undefined>;
+    /**
+     * Definitions for element features, including names and values.
+     */
+    readonly elementFeatureDefs: _angular_core.InputSignal<FeatureDefinitions | undefined>;
+    /**
+     * Definitions for diplomatic features, including names and values.
+     */
+    readonly diplomaticFeatureDefs: _angular_core.InputSignal<FeatureDefinitions | undefined>;
+    /**
+     * Emitted when the operation is changed.
+     */
+    readonly operationChange: _angular_core.OutputEmitterRef<CharChainOperation>;
+    /**
+     * Emitted when the operation preview is requested.
+     */
+    readonly operationPreview: _angular_core.OutputEmitterRef<CharChainOperation>;
+    /**
+     * Emitted when operation editing is cancelled.
+     */
+    readonly operationCancel: _angular_core.OutputEmitterRef<void>;
+    readonly tabIndex: _angular_core.WritableSignal<number>;
+    readonly id: _angular_core.WritableSignal<string | undefined>;
+    readonly hasTo: _angular_core.WritableSignal<boolean>;
+    readonly hasToRun: _angular_core.WritableSignal<boolean>;
+    readonly hasValue: _angular_core.WritableSignal<boolean>;
+    readonly elements: _angular_core.WritableSignal<SVGElement[]>;
+    readonly editedElementId: _angular_core.WritableSignal<string | undefined>;
+    readonly editedSource: _angular_core.WritableSignal<OperationSource | undefined>;
+    readonly editedSourceIndex: _angular_core.WritableSignal<number>;
+    rank: FormControl<number>;
+    groupId: FormControl<string | null>;
+    features: FormControl<Feature[]>;
+    sources: FormControl<OperationSource[]>;
+    type: FormControl<OperationType>;
+    at: FormControl<number>;
+    atAsIndex: FormControl<boolean>;
+    to: FormControl<number>;
+    toAsIndex: FormControl<boolean>;
+    inputTag: FormControl<string | null>;
+    outputTag: FormControl<string | null>;
+    run: FormControl<number>;
+    toRun: FormControl<number>;
+    value: FormControl<string | null>;
+    svg: FormControl<string>;
+    elementFeatures: FormControl<Record<string, Feature[]>>;
+    newTextHidden: FormControl<boolean>;
+    dpFeatures: FormControl<Feature[]>;
+    form: FormGroup;
+    constructor(formBuilder: FormBuilder, _clipboard: Clipboard, _settings: SettingsService, _dialogService: DialogService);
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    private hasTextChanges;
+    onCreateEditor(editor: monaco.editor.IEditor): void;
+    onFeaturesChange(features: OperationFeature[]): void;
+    onDpFeaturesChange(features: Feature[]): void;
+    addSource(): void;
+    editSource(index: number): void;
+    closeSource(): void;
+    onSourceChange(source: OperationSource): void;
+    saveSvg(): void;
+    openSvgEditor(): void;
+    loadSvg(): void;
+    setSvgFromClipboard(): void;
+    private parseSvg;
+    removeDecimals(): void;
+    wrapInGroup(): void;
+    onTabIndexChange(index: number): void;
+    editElementFeatures(element: SVGElement): void;
+    deleteElementFeatures(element: SVGElement): void;
+    onElementFeaturesChange(features: Feature[]): void;
+    private updateArgsUI;
+    private updateForm;
+    cancel(): void;
+    private getOperation;
+    requestPreview(): void;
+    save(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChainOperationEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChainOperationEditorComponent, "gve-chain-operation-editor", never, { "operation": { "alias": "operation"; "required": false; "isSignal": true; }; "snapshot": { "alias": "snapshot"; "required": false; "isSignal": true; }; "hidePreview": { "alias": "hidePreview"; "required": false; "isSignal": true; }; "featureDefs": { "alias": "featureDefs"; "required": false; "isSignal": true; }; "elementFeatureDefs": { "alias": "elementFeatureDefs"; "required": false; "isSignal": true; }; "diplomaticFeatureDefs": { "alias": "diplomaticFeatureDefs"; "required": false; "isSignal": true; }; }, { "operation": "operationChange"; "operationChange": "operationChange"; "operationPreview": "operationPreview"; "operationCancel": "operationCancel"; }, never, never, true, never>;
+}
+
+/**
+ * 🔑 `gve-chain-result-view`
+ *
+ * Component to display a chain result. This provides a version picker
+ * by staged version or simple step, and shows the selected step's text
+ * and features, plus a steps map. User can pick a step from both the
+ * pickers or the map.
+ * Used by the `gve-snapshot-editor` component.
+ *
+ * - ▶️ `result` (`CharChainResult`): the result to display.
+ * - 🔥 `stepPick` (`ChainOperationContextStep`): emitted when a
+ * result's step is picked by the user.
+ */
+declare class ChainResultViewComponent implements OnInit, OnDestroy, AfterViewInit {
+    private _subs?;
+    private _stepSelectionDone;
+    private _viewInitialized;
+    /**
+     * The result to display.
+     */
+    readonly result: _angular_core.InputSignal<CharChainResult | undefined>;
+    /**
+     * The index of the initial step to display after the result is set.
+     * If the index is negative, it is counted from the end of the steps.
+     */
+    readonly initialStepIndex: _angular_core.InputSignal<number | undefined>;
+    /**
+     * Emitted when a result's step is picked by the user.
+     */
+    readonly stepPick: _angular_core.OutputEmitterRef<ChainOperationContextStep>;
+    readonly versionTags: _angular_core.WritableSignal<string[]>;
+    readonly tags: _angular_core.WritableSignal<string[]>;
+    readonly step: _angular_core.WritableSignal<ChainOperationContextStep | undefined>;
+    readonly selection: _angular_core.WritableSignal<string | undefined>;
+    readonly selectionFeatures: _angular_core.WritableSignal<OperationFeature[]>;
+    versionTag: FormControl<string | null>;
+    tag: FormControl<string | null>;
+    constructor(formBuilder: FormBuilder);
+    private doInitialStepSelection;
+    ngOnInit(): void;
+    ngAfterViewInit(): void;
+    getCharColor(node: CharNode): string | null;
+    private selectInitialStep;
+    ngOnDestroy(): void;
+    private updateVersionTags;
+    private getTagFromVersion;
+    private updateForm;
+    private getNodeFeatures;
+    private findNode;
+    onTextCharPick(event: BaseTextCharEvent): void;
+    onTextRangePick(range: VarBaseTextRange): void;
+    onStepChange(step?: ChainOperationContextStep): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChainResultViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChainResultViewComponent, "gve-chain-result-view", never, { "result": { "alias": "result"; "required": false; "isSignal": true; }; "initialStepIndex": { "alias": "initialStepIndex"; "required": false; "isSignal": true; }; }, { "stepPick": "stepPick"; }, never, never, true, never>;
+}
+
+type GraphvizRankdir = 'TB' | 'LR' | 'BT' | 'RL';
+declare class GveGraphvizService {
+    private hashString;
+    private hslToRgb;
+    private getColorForTag;
+    private getExcludedNodeIds;
+    /**
+     * Represent the received chain as a Graphviz digraph.
+     *
+     * @param chain The source chain if any.
+     * @param tags The tags to show. When set, only the links with these tags are shown.
+     * @param rankdir The rank direction.
+     * @returns Graphviz representation of the chain.
+     */
+    generateGraph(chain?: CharChain, tags?: string[], rankdir?: GraphvizRankdir): string;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<GveGraphvizService, never>;
+    static ɵprov: _angular_core.ɵɵInjectableDeclaration<GveGraphvizService>;
+}
+
+declare class ChainViewComponent implements OnDestroy {
+    private _graphviz;
+    private _settings;
+    private _clipboard;
+    private _snackbar;
+    private readonly _sub?;
+    /**
+     * The chain to display.
+     */
+    readonly chain: _angular_core.InputSignal<CharChain | undefined>;
+    /**
+     * The direction of the graph.
+     */
+    readonly direction: _angular_core.InputSignal<GraphvizRankdir>;
+    /**
+     * All the distinct tags in the chain.
+     */
+    readonly tags: _angular_core.Signal<string[]>;
+    /**
+     * The tags to show, or empty to show all of them.
+     */
+    readonly selectedTags: _angular_core.ModelSignal<string[]>;
+    /**
+     * The Graphviz representation of the chain.
+     */
+    readonly graph: _angular_core.Signal<string>;
+    userTags: FormControl<string[]>;
+    constructor(_graphviz: GveGraphvizService, _settings: SettingsService, _clipboard: Clipboard, _snackbar: MatSnackBar);
+    ngOnDestroy(): void;
+    copyGraph(): void;
+    openExternalEditor(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<ChainViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<ChainViewComponent, "gve-chain-view", never, { "chain": { "alias": "chain"; "required": false; "isSignal": true; }; "direction": { "alias": "direction"; "required": false; "isSignal": true; }; "selectedTags": { "alias": "selectedTags"; "required": false; "isSignal": true; }; }, { "selectedTags": "selectedTagsChange"; }, never, never, true, never>;
+}
+
+/**
+ * 🔑 `gve-feature-set-editor`
+ *
+ * Component for editing a set of features. It shows a list of features,
+ * allowing to edit each of them or adding new ones. Optionally you can
+ * specify a list of feature names and values to use in the selection.
+ * Used by base text editor and chain operation editor components.
+ *
+ * - ▶️ `featNames` (`LabeledId[]`): the list of feature names to display
+ * in the _name_ selection. This is used when you have a closed list of features.
+ * - ▶️ `featValues` (`FeatureMap`): the feature values map. When specified
+ * and the user selects a feature name present in the map keys, the corresponding
+ * values will be used to populate the value selection.
+ * - ▶️ `filterThreshold` (`number`): the threshold at which the features filter
+ * should become visible. If set to 0, the filter is always visible; if set to -1,
+ * it is always invisible; otherwise, it gets visible when the number of features
+ * is equal to or greater than the threshold. Default is 5.
+ * - ▶️ `features` (`Feature[]`): the features to edit.
+ * - ▶️ `isVar`: true if the feature is a variant operation feature, which
+ * has additional properties like negation, global, and short-lived.
+ * - 🔥 `featuresChange` (`Feature[]`): emitted when features have changed.
+ */
+declare class FeatureSetEditorComponent implements OnInit, OnDestroy {
+    private _sub?;
+    readonly POLICIES: string[];
+    /**
+     * True if the feature is a variant operation feature, which has
+     * additional properties like negation, global, and short-lived.
+     */
+    readonly isVar: _angular_core.InputSignal<boolean>;
+    /**
+     * The list of feature names to display in the name selection.
+     * This is used when you have a closed list of features.
+     */
+    readonly featNames: _angular_core.InputSignal<LabeledId[] | undefined>;
+    /**
+     * The feature values map. When specified and the user selects a feature
+     * name present in the map keys, the corresponding values will be used
+     * to populate the value selection.
+     */
+    readonly featValues: _angular_core.InputSignal<FeatureMap | undefined>;
+    /**
+     * The threshold at which the features filter should become visible.
+     * If set to 0, the filter is always visible; if set to -1, it is always
+     * invisible; otherwise, it gets visible when the number of features
+     * is greater than or equal to the threshold. Default is 5.
+     */
+    readonly filterThreshold: _angular_core.InputSignal<number>;
+    /**
+     * The features to edit.
+     */
+    readonly features: _angular_core.ModelSignal<Feature[] | OperationFeature[]>;
+    readonly editedFeature: _angular_core.WritableSignal<Feature | OperationFeature | undefined>;
+    readonly editedFeatureIndex: _angular_core.WritableSignal<number>;
+    filteredFeatures: _angular_core.WritableSignal<Feature[] | OperationFeature[]>;
+    filter: FormControl<string | null>;
+    constructor(formBuilder: FormBuilder);
+    private applyFeatureFilter;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    addFeature(): void;
+    editFeature(feature: Feature | OperationFeature): void;
+    deleteFeature(feature: Feature | OperationFeature): void;
+    onFeatureChange(feature?: Feature | OperationFeature): void;
+    onFeatureCancel(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FeatureSetEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FeatureSetEditorComponent, "gve-feature-set-editor", never, { "isVar": { "alias": "isVar"; "required": false; "isSignal": true; }; "featNames": { "alias": "featNames"; "required": false; "isSignal": true; }; "featValues": { "alias": "featValues"; "required": false; "isSignal": true; }; "filterThreshold": { "alias": "filterThreshold"; "required": false; "isSignal": true; }; "features": { "alias": "features"; "required": false; "isSignal": true; }; }, { "features": "featuresChange"; }, never, never, true, never>;
+}
+
+/**
+ * 🔑 `gve-feature-set-view`
+ *
+ * A component to display a list of features.
+ * Used by the chain result view component.
+ *
+ * - ▶️ `features` (`Feature[]`): the features to display.
+ * - ▶️ `featNames` (`LabeledId[]`): the list of feature names to display
+ * in the _name_ selection. This is used when you have a closed list of features.
+ * - ▶️ `featValues` (`FeatureMap`): the feature values map. When specified
+ * and the user selects a feature name present in the map keys, the corresponding
+ * values will be used to populate the value selection.
+ * - ▶️ `filterThreshold` (`number`): the threshold at which the features filter
+ * should become visible. If set to 0, the filter is always visible; if set to -1,
+ * it is always invisible; otherwise, it gets visible when the number of features
+ * is greater than the threshold. Default is 5.
+ */
+declare class FeatureSetViewComponent {
+    private _sub?;
+    /**
+     * The features.
+     */
+    readonly features: _angular_core.InputSignal<Feature[] | OperationFeature[]>;
+    /**
+     * The list of feature names to display in the name selection.
+     * This is used when you have a closed list of features.
+     */
+    readonly featNames: _angular_core.InputSignal<LabeledId[] | undefined>;
+    /**
+     * The feature values map. When specified and the user selects a feature
+     * name present in the map keys, the corresponding values will be used
+     * to populate the value selection.
+     */
+    readonly featValues: _angular_core.InputSignal<FeatureMap | undefined>;
+    /**
+     * The threshold at which the features filter should become visible.
+     * If set to 0, the filter is always visible; if set to -1, it is always
+     * invisible; otherwise, it gets visible when the number of features
+     * is greater than the threshold. Default is 5.
+     */
+    readonly filterThreshold: _angular_core.InputSignal<number>;
+    readonly filteredFeatures: _angular_core.WritableSignal<Feature[] | OperationFeature[]>;
+    filter: FormControl<string | null>;
+    constructor(formBuilder: FormBuilder);
+    private applyFeatureFilter;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<FeatureSetViewComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<FeatureSetViewComponent, "gve-feature-set-view", never, { "features": { "alias": "features"; "required": false; "isSignal": true; }; "featNames": { "alias": "featNames"; "required": false; "isSignal": true; }; "featValues": { "alias": "featValues"; "required": false; "isSignal": true; }; "filterThreshold": { "alias": "filterThreshold"; "required": false; "isSignal": true; }; }, {}, never, never, true, never>;
+}
+
+/**
+ * 🔑 `gve-ln-heights-editor`
+ *
+ * A component to edit line heights.
+ * Used by the `gve-snapshot-editor` component.
+ *
+ * - ▶️ `lineCount` (`number`): the number of lines.
+ * - ▶️ `heights` (`Record<number, number>`): the line heights.
+ * - 🔥 `heightsChange` (`EventEmitter<Record<number, number>>`): the event
+ * emitted when the heights change.
+ */
+declare class LnHeightsEditorComponent implements OnInit, OnDestroy {
+    private _subs?;
+    private _heights?;
+    lineNumber: FormControl<number>;
+    height: FormControl<number>;
+    /**
+     * The total number of lines in the text.
+     */
+    readonly lineCount: _angular_core.InputSignal<number>;
+    /**
+     * The heights map of the lines. Each key is a line number and the value is
+     * the height of the line.
+     */
+    readonly heights: _angular_core.InputSignal<Record<number, number> | undefined>;
+    /**
+     * The event emitted when the heights change.
+     */
+    readonly heightsChange: _angular_core.OutputEmitterRef<Record<number, number> | undefined>;
+    readonly lineNumbers: _angular_core.Signal<number[]>;
+    constructor(formBuilder: FormBuilder);
+    private pruneHeights;
+    ngOnInit(): void;
+    ngOnDestroy(): void;
+    reset(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<LnHeightsEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<LnHeightsEditorComponent, "gve-ln-heights-editor", never, { "lineCount": { "alias": "lineCount"; "required": false; "isSignal": true; }; "heights": { "alias": "heights"; "required": false; "isSignal": true; }; }, { "heightsChange": "heightsChange"; }, never, never, true, never>;
+}
+
+/**
+ * 🔑 `gve-operation-source-editor`
+ *
+ * A component to edit an operation source.
+ * Used by chain operation editor component.
+ *
+ * - ▶️ `source` (`OperationSource`): the source to edit.
+ * - ▶️ `ids` (`LabeledId[]`): the list of source IDs, when using a closed
+ * list for them.
+ * - ▶️ `types` (`LabeledId[]`): the list of source types, when using a closed
+ * list for them.
+ * - 🔥 `sourceChange` (`EventEmitter<OperationSource>`): the event emitted
+ * when the source changes.
+ * - 🔥 `sourceCancel` (`EventEmitter<void>`): the event emitted when the
+ * edit is canceled.
+ */
+declare class OperationSourceEditorComponent {
+    /**
+     * The source to edit.
+     */
+    readonly source: _angular_core.ModelSignal<OperationSource | undefined>;
+    /**
+     * The list of source IDs when it's a closed set.
+     */
+    readonly ids: _angular_core.InputSignal<LabeledId[] | undefined>;
+    /**
+     * The list of source types when it's a closed set.
+     */
+    readonly types: _angular_core.InputSignal<LabeledId[] | undefined>;
+    /**
+     * The event emitted when the edit is canceled.
+     */
+    sourceCancel: _angular_core.OutputEmitterRef<void>;
+    id: FormControl<string>;
+    type: FormControl<string>;
+    rank: FormControl<number>;
+    note: FormControl<string | null>;
+    form: FormGroup;
+    constructor(formBuilder: FormBuilder);
+    private updateForm;
+    cancel(): void;
+    save(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<OperationSourceEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<OperationSourceEditorComponent, "gve-operation-source-editor", never, { "source": { "alias": "source"; "required": false; "isSignal": true; }; "ids": { "alias": "ids"; "required": false; "isSignal": true; }; "types": { "alias": "types"; "required": false; "isSignal": true; }; }, { "source": "sourceChange"; "sourceCancel": "sourceCancel"; }, never, never, true, never>;
+}
+
+/**
+ * 🔑 `gve-snapshot-editor`
+ *
+ * A component to edit a text snapshot. This is the top level component in the GVE core
+ * library.
+ *
+ * - ▶️ `snapshot` (`Snapshot`): the snapshot to edit.
+ * - ▶️ `batchOps` (`string`): the batch operations text to set for the editor.
+ * - ▶️ `noSave` (`boolean`): true to disable saving.
+ * - 🔥 `snapshotChange` (`Snapshot`): emitted when the user saves the edited snapshot.
+ * - 🔥 `snapshotCancel` (`void`): emitted when the user cancels the snapshot editing.
+ */
+declare class SnapshotEditorComponent {
+    private _api;
+    private _dialog;
+    private _dialogService;
+    private _snackbar;
+    private readonly _nanoid;
+    private _renderer?;
+    private _previewing?;
+    private _transparentIds?;
+    private _stepPickFrozen?;
+    private _handlingOver?;
+    private _lastOverId?;
+    snapshotView?: ElementRef<SnapshotViewComponent>;
+    /**
+     * The snapshot to edit.
+     */
+    readonly snapshot: _angular_core.ModelSignal<Snapshot | undefined>;
+    /**
+     * The batch operations text to set for the editor.
+     */
+    readonly batchOps: _angular_core.InputSignal<string | undefined>;
+    /**
+     * True to disable saving.
+     */
+    readonly noSave: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * True to enable debug mode for view rendition.
+     */
+    readonly debug: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * True to not show character decoration according to the trace
+     * features in nodes.
+     */
+    readonly noDecoration: _angular_core.InputSignal<boolean | undefined>;
+    /**
+     * Definitions for features, including names and values.
+     */
+    readonly featureDefs: _angular_core.InputSignal<FeatureDefinitions | undefined>;
+    /**
+     * Definitions for element features, including names and values.
+     */
+    readonly elementFeatureDefs: _angular_core.InputSignal<FeatureDefinitions | undefined>;
+    /**
+     * Definitions for diplomatic features, including names and values.
+     */
+    readonly diplomaticFeatureDefs: _angular_core.InputSignal<FeatureDefinitions | undefined>;
+    /**
+     * Emitted when the user cancels the snapshot editing.
+     */
+    readonly snapshotCancel: _angular_core.OutputEmitterRef<void>;
+    width: FormControl<number>;
+    height: FormControl<number>;
+    style: FormControl<string | null>;
+    baseText: FormControl<CharNode[]>;
+    offsetX: FormControl<number>;
+    offsetY: FormControl<number>;
+    lineHeightOffset: FormControl<number>;
+    lnHeights: FormControl<Record<number, number> | null>;
+    charSpacingOffset: FormControl<number>;
+    spcWidthOffset: FormControl<number>;
+    textStyle: FormControl<string | null>;
+    operations: FormControl<CharChainOperation[]>;
+    opStyle: FormControl<string | null>;
+    form: FormGroup;
+    imageUrl: FormControl<string | null>;
+    imageOpacity: FormControl<number>;
+    imageX: FormControl<number>;
+    imageY: FormControl<number>;
+    imageWidth: FormControl<number>;
+    imageHeight: FormControl<number>;
+    defs: FormControl<string | null>;
+    timelines: FormControl<GveAnimationTimeline[]>;
+    readonly showChain: FormControl<boolean>;
+    readonly chain: _angular_core.WritableSignal<CharChain | undefined>;
+    readonly opTags: _angular_core.WritableSignal<string[]>;
+    readonly opElementIds: _angular_core.WritableSignal<string[]>;
+    readonly textRange: _angular_core.WritableSignal<VarBaseTextRange | undefined>;
+    readonly lineCount: _angular_core.WritableSignal<number>;
+    readonly editedOp: _angular_core.WritableSignal<CharChainOperation | undefined>;
+    readonly editedOpIndex: _angular_core.WritableSignal<number>;
+    readonly busy: _angular_core.WritableSignal<boolean>;
+    readonly opTypeMap: {
+        0: string;
+        1: string;
+        2: string;
+        3: string;
+        4: string;
+        5: string;
+        6: string;
+        7: string;
+    };
+    viewTitle: string;
+    viewData?: SnapshotViewData;
+    visualInfo?: string;
+    rulers: boolean;
+    result?: CharChainResult;
+    resultOperationId?: string;
+    initialStepIndex: number;
+    constructor(formBuilder: FormBuilder, _api: GveApiService, _dialog: MatDialog, _dialogService: DialogService, _snackbar: MatSnackBar);
+    /**
+     * Set the view data for the snapshot view.
+     *
+     * @param snapshot The optional snapshot data to use. If not provided,
+     * a snapshot will be created from the form data.
+     * @param title The optional title to set for the view.
+     */
+    private setViewData;
+    private updateForm;
+    inputBaseText(): void;
+    /**
+     * Update the line count based on the received text.
+     * @param text The text to use for counting lines.
+     */
+    private updateLineCount;
+    /**
+     * Handle the event fired by the base text editor to pick a text range.
+     * @param range The picked range.
+     */
+    onRangePick(range?: VarBaseTextRange): void;
+    /**
+     * Update the lists of operation output tags and element IDs by collecting
+     * all the operation tags and the IDs of the elements in their diplomatic.g
+     * SVG code if any.
+     */
+    private updateOpLists;
+    /**
+     * Edit a new operation.
+     */
+    editNewOperation(): void;
+    /**
+     * Edit (a copy of) the operation at the specified index.
+     * @param index The operation index.
+     */
+    editOperation(index: number): void;
+    /**
+     * Close the currently edited operation.
+     */
+    private closeEditedOperation;
+    /**
+     * Handle the event fired by the operation editor to cancel
+     * the current operation edits.
+     */
+    onOperationCancel(): void;
+    /**
+     * Handle the event fired by the operation editor to change
+     * the currently edited operation, or add a new one if that
+     * was a new operation.
+     * @param op The changed operation.
+     */
+    onOperationChange(op?: CharChainOperation | null): void;
+    /**
+     * Delete the operation at the specified index.
+     * @param index The index of the operation to delete.
+     */
+    deleteOperation(index: number): void;
+    /**
+     * Parse the operations from their text and append them to the current
+     * snapshot operations.
+     */
+    parseOperations(): void;
+    /**
+     * Remove all the operations, close the edited operation and update the view data.
+     */
+    private removeAllOperations;
+    /**
+     * Remove all the operations.
+     */
+    clearOperations(): void;
+    /**
+     * Parse all the id attributes from the received SVG code and
+     * return them as an array.
+     *
+     * @param svg The SVG content to parse or undefined.
+     * @returns Array of IDs found in the SVG content or undefined.
+     */
+    private parseSvgIds;
+    private getTransparentIds;
+    /**
+     * Supply operation nodes to the snapshot text nodes. An execution result is
+     * a compact object, so that to build a snapshot accumulating all the nodes
+     * and their features up to the last executed operation, we need to start
+     * with the base text nodes, and then examine each execution step in the
+     * result. Each step contains only those nodes used by the version of the
+     * text corresponding to its stage. Among them, some are new nodes, and some
+     * are base text nodes. Also, the step contains the full set of features
+     * current at its time, both for the text as a whole and for each node.
+     * This method accumulates the nodes and their features up to the specified
+     * step, updating the features of the nodes already present in the snapshot
+     * text nodes, and adding the new nodes.
+     *
+     * @param snapshot The snapshot to supply the nodes to.
+     * @param result The operations execution result.
+     * @param tag The output tag of the operation to supply the nodes from.
+     */
+    private supplyOpNodes;
+    /**
+     * Run the operations up to the specified index (included).
+     * This is called when:
+     * - a preview is requested by the operation editor.
+     * - the currently edited operation is saved.
+     * - the user picks a step in the chain result view.
+     * - runToLast is called, which happens when:
+     *   - setting the snapshot.
+     *   - parsing a batch of operations.
+     *   - deleting an operation.
+     *
+     * @param index The index of the operation to run to.
+     * @param lastOperation The operation to use in place of the existing
+     * operation in the snapshot at index. This is used when previewing
+     * the edited operation from within the operation editor.
+     * @returns A promise that resolves to the execution result.
+     */
+    runTo(index: number, lastOperation?: CharChainOperation): void;
+    /**
+     * Run the operations up to the last operation if any, updating the
+     * execution result. The execution result is always the result from
+     * all the operations, as users must be able to browse across its steps.
+     */
+    runToLast(): void;
+    getChainAt(index: number, lastOperation?: CharChainOperation): void;
+    /**
+     * Update the snapshot view by running the operations up to the
+     * currently edited operation if any.
+     *
+     * @param operation The operation being previewed.
+     */
+    onOperationPreview(operation: CharChainOperation): void;
+    private playTimeline;
+    /**
+     * Handle the event fired by the chain result view to pick a step.
+     *
+     * @param step The step to pick.
+     */
+    onStepPick(step: ChainOperationContextStep): void;
+    /**
+     * Handle the event fired by a visual in the snapshot view.
+     *
+     * @param event The event.
+     */
+    onVisualEvent(event: CustomEvent<GveVisualEvent>): void;
+    /**
+     * Handle the change of line heights by updating the form control.
+     *
+     * @param heights The line heights.
+     */
+    onHeightsChange(heights: Record<number, number> | undefined): void;
+    /**
+     * Handle the change of timelines by updating the form control.
+     *
+     * @param timelines The timelines.
+     */
+    onTimelinesChange(timelines?: GveAnimationTimeline[] | null): void;
+    /**
+     * Emit the cancel event for this snapshot edit.
+     */
+    close(): void;
+    /**
+     * Handle the render event from the snapshot view to get a reference
+     * to the renderer.
+     *
+     * @param event The rendition event.
+     */
+    onSnapshotRender(event: CustomEvent<SnapshotViewRenderEvent>): void;
+    onImageLoad(imageElement: HTMLImageElement): void;
+    onImageOpacityChange(value: number): void;
+    resetImgMetadata(): void;
+    /**
+     * Toggle rulers in the snapshot view.
+     */
+    toggleRulers(): void;
+    private defaultCharDecorator;
+    /**
+     * Get a snapshot from the form data.
+     *
+     * @returns New snapshot object.
+     */
+    private getSnapshot;
+    /**
+     * Get a snapshot from the form data and emit it
+     * in the snapshot change event.
+     */
+    save(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SnapshotEditorComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SnapshotEditorComponent, "gve-snapshot-editor", never, { "snapshot": { "alias": "snapshot"; "required": false; "isSignal": true; }; "batchOps": { "alias": "batchOps"; "required": false; "isSignal": true; }; "noSave": { "alias": "noSave"; "required": false; "isSignal": true; }; "debug": { "alias": "debug"; "required": false; "isSignal": true; }; "noDecoration": { "alias": "noDecoration"; "required": false; "isSignal": true; }; "featureDefs": { "alias": "featureDefs"; "required": false; "isSignal": true; }; "elementFeatureDefs": { "alias": "elementFeatureDefs"; "required": false; "isSignal": true; }; "diplomaticFeatureDefs": { "alias": "diplomaticFeatureDefs"; "required": false; "isSignal": true; }; }, { "snapshot": "snapshotChange"; "snapshotCancel": "snapshotCancel"; }, never, never, true, never>;
+}
+
+/**
+ * 🔑 `gve-snapshot-text-editor`
+ *
+ * A component to edit a snapshot text. This component can be used both in a dialog
+ * and as a standalone component.
+ *
+ * - ▶️ `text` (`CharNode[]`): the text to edit.
+ * - 🔥 `textChange` (`CharNode[]`): event emitted when text changes.
+ */
+declare class SnapshotTextEditorComponent implements OnInit {
+    dialogRef?: MatDialogRef<SnapshotTextEditorComponent> | undefined;
+    data?: PayloadMatDialogConfig<{
+        text?: CharNode[];
+    }> | undefined;
+    userText: FormControl<string>;
+    form: FormGroup;
+    readonly text: _angular_core.ModelSignal<CharNode[]>;
+    constructor(formBuilder: FormBuilder, dialogRef?: MatDialogRef<SnapshotTextEditorComponent> | undefined, data?: PayloadMatDialogConfig<{
+        text?: CharNode[];
+    }> | undefined);
+    private updateUserText;
+    ngOnInit(): void;
+    close(): void;
+    save(): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<SnapshotTextEditorComponent, [null, { optional: true; }, { optional: true; }]>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<SnapshotTextEditorComponent, "gve-snapshot-text-editor", never, { "text": { "alias": "text"; "required": false; "isSignal": true; }; }, { "text": "textChange"; }, never, never, true, never>;
+}
+
+/**
+ * 🔑 `gve-steps-map`
+ *
+ * A map of steps in a chain operation context. This shows the list of
+ * steps in the execution of a set of operations, and allows the user to
+ * pick a step to view.
+ *
+ * Used by the `gve-chain-result-view` component.
+ *
+ * - ▶️ `steps` (`ChainOperationContextStep[]`): the steps to display.
+ * - ▶️ `selectedStep` (`ChainOperationContextStep`): the step that is
+ * currently selected.
+ * - ▶️ `textFontSize` (`string`): the font size of the steps text.
+ * - 🔥 `selectedStepChange` (`ChainOperationContextStep`): emitted when
+ * the selectd step has been changed by the user. This is not emitted
+ * when the selected step is changed programmatically, unless this is
+ * the first time the steps are set. In that case, the last step is
+ * automatically selected.
+ */
+declare class StepsMapComponent implements AfterViewInit {
+    private _viewInitialized;
+    private _selectionProcessed;
+    readonly lines: _angular_core.WritableSignal<{
+        [key: string]: string[];
+    }>;
+    /**
+     * The steps to display.
+     */
+    readonly steps: _angular_core.InputSignal<ChainOperationContextStep[]>;
+    /**
+     * The step that is currently selected.
+     */
+    readonly selectedStep: _angular_core.ModelSignal<ChainOperationContextStep | undefined>;
+    /**
+     * The font size of the steps text.
+     */
+    readonly textFontSize: _angular_core.InputSignal<string>;
+    constructor();
+    private validateAndSetSelection;
+    ngAfterViewInit(): void;
+    private updateLines;
+    onStepClick(step: ChainOperationContextStep): void;
+    static ɵfac: _angular_core.ɵɵFactoryDeclaration<StepsMapComponent, never>;
+    static ɵcmp: _angular_core.ɵɵComponentDeclaration<StepsMapComponent, "gve-steps-map", never, { "steps": { "alias": "steps"; "required": false; "isSignal": true; }; "selectedStep": { "alias": "selectedStep"; "required": false; "isSignal": true; }; "textFontSize": { "alias": "textFontSize"; "required": false; "isSignal": true; }; }, { "selectedStep": "selectedStepChange"; }, never, never, true, never>;
+}
+
+export { AnimationTimelineComponent, AnimationTimelineSetComponent, AnimationTweenComponent, BaseTextCharComponent, BaseTextEditorComponent, BaseTextViewComponent, BatchOperationEditorComponent, ChainOperationEditorComponent, ChainResultViewComponent, ChainViewComponent, FeatureEditorComponent, FeatureSetEditorComponent, FeatureSetViewComponent, GveApiService, GveGraphvizService, LnHeightsEditorComponent, OperationSourceEditorComponent, SettingsService, SnapshotEditorComponent, SnapshotTextEditorComponent, StepsMapComponent };
+export type { BaseTextChar, BaseTextCharEvent, ChainOperationContextStep, ChainOperationTags, CharChain, CharChainLink, CharChainNode, CharChainResult, FeatureDefinitions, FeatureMap, GraphvizRankdir, PayloadMatDialogConfig, ResultWrapper, VarBaseTextRange };