@pbkware/fielded-text-web 0.1.0

package/src/meta/sequences/core/ft-meta-sequence-list.ts

@@ -0,0 +1,203 @@
+// Meta sequence list - manages all sequences in metadata
+
+import type { FtMetaFieldList } from '../../fields/ft-meta-field-list.js';
+import type { FtMetaField } from '../../fields/ft-meta-field.js';
+import { FtMetaSequence } from './ft-meta-sequence.js';
+
+/**
+ * @public
+ */
+export class FtMetaSequenceList {
+  private readonly _list: FtMetaSequence[] = [];
+
+  get count(): number {
+    return this._list.length;
+  }
+
+  get(index: number): FtMetaSequence {
+    return this._list[index];
+  }
+
+  getByName(name: string): FtMetaSequence {
+    const index = this.indexOfName(name);
+    if (index < 0) {
+      throw new Error(`Meta sequence not found: ${name}`);
+    }
+    return this._list[index];
+  }
+
+  set(value: readonly FtMetaSequence[]): void {
+    this.clear();
+    const count = value.length;
+    for (let i = 0; i < count; i++) {
+      this.add(value[i]);
+    }
+  }
+
+  new(name?: string): FtMetaSequence {
+    const sequence = new FtMetaSequence();
+    if (name !== undefined) {
+      sequence.name = name;
+    }
+    this.add(sequence);
+    return sequence;
+  }
+
+  removeAt(index: number): void {
+    this.unbindSequenceEvents(this._list[index]);
+    this._list.splice(index, 1);
+  }
+
+  remove(sequence: FtMetaSequence): void {
+    const index = this._list.indexOf(sequence);
+    if (index >= 0) {
+      this.removeAt(index);
+    }
+  }
+
+  clear(): void {
+    for (const sequence of this._list) {
+      this.unbindSequenceEvents(sequence);
+    }
+    this._list.length = 0;
+  }
+
+  removeField(field: FtMetaField): void {
+    for (const sequence of this._list) {
+      sequence.removeItemsWithField(field);
+    }
+  }
+
+  removeAllFields(): void {
+    for (const sequence of this._list) {
+      sequence.removeAllItems();
+    }
+  }
+
+  indexOf(sequence: FtMetaSequence): number {
+    return this._list.indexOf(sequence);
+  }
+
+  indexOfName(name: string): number {
+    for (let i = 0; i < this._list.length; i++) {
+      if (FtMetaSequence.sameName(this._list[i].name, name)) {
+        return i;
+      }
+    }
+    return -1;
+  }
+
+  indexOfRoot(): number {
+    for (let i = 0; i < this._list.length; i++) {
+      if (this._list[i].root) {
+        return i;
+      }
+    }
+    return -1;
+  }
+
+  assign(source: FtMetaSequenceList, fieldList: FtMetaFieldList, sourceFieldList: FtMetaFieldList): void {
+    this._list.length = 0;
+
+    // Create copies of sequences (excluding redirects)
+    for (let i = 0; i < source.count; i++) {
+      const sequence = source.get(i).createCopyExcludingRedirects(fieldList, sourceFieldList);
+      this.add(sequence);
+    }
+
+    // All sequences need to be created before we can assign redirects
+    for (let i = 0; i < this.count; i++) {
+      this._list[i].assignRedirects(this, source);
+    }
+  }
+
+  isMoreThanOneRoot(): {
+    found: boolean;
+    firstRootSequenceName: string;
+    secondRootSequenceName: string;
+  } {
+    let firstRootSequenceName = '';
+    let secondRootSequenceName = '';
+    let firstSequenceRootFound = false;
+
+    for (let i = 0; i < this.count; i++) {
+      if (this._list[i].root) {
+        if (!firstSequenceRootFound) {
+          firstRootSequenceName = this._list[i].name;
+          firstSequenceRootFound = true;
+        } else {
+          secondRootSequenceName = this._list[i].name;
+          return {
+            found: true,
+            firstRootSequenceName,
+            secondRootSequenceName,
+          };
+        }
+      }
+    }
+
+    return {
+      found: false,
+      firstRootSequenceName,
+      secondRootSequenceName,
+    };
+  }
+
+  hasDuplicateName(): { found: boolean; duplicateName: string } {
+    for (let i = 0; i < this.count; i++) {
+      if (this.indexOfName(this._list[i].name) !== i) {
+        return {
+          found: true,
+          duplicateName: this._list[i].name,
+        };
+      }
+    }
+
+    return {
+      found: false,
+      duplicateName: '',
+    };
+  }
+
+  anyItemWithUndefinedField(sequenceIndex: number): {
+    found: boolean;
+    itemIndex: number;
+  } {
+    if (sequenceIndex >= 0 && sequenceIndex < this.count) {
+      return this._list[sequenceIndex].anyItemWithUndefinedField();
+    }
+    return { found: false, itemIndex: -1 };
+  }
+
+  anyItemWithConstantFieldHasRedirects(sequenceIndex: number): {
+    found: boolean;
+    itemIndex: number;
+  } {
+    if (sequenceIndex >= 0 && sequenceIndex < this.count) {
+      return this._list[sequenceIndex].anyItemWithConstantFieldHasRedirects();
+    }
+    return { found: false, itemIndex: -1 };
+  }
+
+  private add(sequence: FtMetaSequence): void {
+    this._list.push(sequence);
+    this.bindSequenceEvents(sequence);
+  }
+
+  private bindSequenceEvents(sequence: FtMetaSequence): void {
+    sequence.rootedEvent = (rootedSequence) => this.handleSequenceRootedEvent(rootedSequence);
+  }
+
+  private unbindSequenceEvents(sequence: FtMetaSequence): void {
+    sequence.rootedEvent = undefined;
+  }
+
+  private handleSequenceRootedEvent(rootedSequence: FtMetaSequence): void {
+    // When one sequence becomes root, all others must be unrooted
+    for (const sequence of this._list) {
+      if (sequence !== rootedSequence && sequence.root) {
+        sequence.root = false;
+      }
+    }
+  }
+}

package/src/meta/sequences/core/ft-meta-sequence.ts

@@ -0,0 +1,127 @@
+// Meta sequence - defines a repeating sequence of fields
+
+import type { FtMetaFieldList } from '../../fields/ft-meta-field-list.js';
+import type { FtMetaField } from '../../fields/ft-meta-field.js';
+import { FtMetaSequenceItemList } from './ft-meta-sequence-item-list.js';
+import { FtMetaSequenceItem } from './ft-meta-sequence-item.js';
+import type { FtMetaSequenceList } from './ft-meta-sequence-list.js';
+
+/**
+ * @public
+ */
+export const DEFAULT_SEQUENCE_NAME = '';
+/**
+ * @public
+ */
+export const DEFAULT_ROOT = false;
+
+/**
+ * @public
+ */
+export type RootedEventHandler = (sequence: FtMetaSequence) => void;
+
+/**
+ * @public
+ */
+export class FtMetaSequence {
+  // Event handler for when this sequence becomes root
+  rootedEvent: RootedEventHandler | undefined;
+
+  private readonly _itemList: FtMetaSequenceItemList;
+  private _name: string;
+  private _root: boolean;
+
+  constructor() {
+    this._itemList = new FtMetaSequenceItemList();
+    this._name = DEFAULT_SEQUENCE_NAME;
+    this._root = DEFAULT_ROOT;
+  }
+
+  get name(): string {
+    return this._name;
+  }
+
+  set name(value: string) {
+    this._name = value;
+  }
+
+  get root(): boolean {
+    return this._root;
+  }
+
+  set root(value: boolean) {
+    this._root = value;
+    if (this._root && this.rootedEvent) {
+      this.rootedEvent(this);
+    }
+  }
+
+  get itemList(): FtMetaSequenceItemList {
+    return this._itemList;
+  }
+
+  static sameName(left: string, right: string): boolean {
+    return left.toLowerCase() === right.toLowerCase();
+  }
+
+  setItemList(items: readonly FtMetaSequenceItem[]): void {
+    this._itemList.set(items);
+  }
+
+  loadDefaults(): void {
+    this._name = DEFAULT_SEQUENCE_NAME;
+    this._root = DEFAULT_ROOT;
+  }
+
+  removeItemsWithField(field: FtMetaField): void {
+    for (let i = this._itemList.count - 1; i >= 0; i--) {
+      if (this._itemList.get(i).field === field) {
+        this._itemList.removeAt(i);
+      }
+    }
+  }
+
+  removeAllItems(): void {
+    this._itemList.clear();
+  }
+
+  createCopyExcludingRedirects(fieldList: FtMetaFieldList, sourceFieldList: FtMetaFieldList): FtMetaSequence {
+    const sequence = new FtMetaSequence();
+    sequence.assignExcludingRedirects(this, fieldList, sourceFieldList);
+    return sequence;
+  }
+
+  assignExcludingRedirects(source: FtMetaSequence, fieldList: FtMetaFieldList, sourceFieldList: FtMetaFieldList): void {
+    this._name = source._name;
+    this._root = source._root;
+    this._itemList.assignExcludingRedirects(source._itemList, fieldList, sourceFieldList);
+  }
+
+  assignRedirects(sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): void {
+    this._itemList.assignRedirects(sequenceList, sourceSequenceList);
+  }
+
+  anyItemWithUndefinedField(): { found: boolean; itemIndex: number } {
+    for (let i = 0; i < this._itemList.count; i++) {
+      const item = this._itemList.get(i);
+      // eslint-disable-next-line @typescript-eslint/no-unnecessary-condition
+      if (!item.field) {
+        return { found: true, itemIndex: i };
+      }
+    }
+    return { found: false, itemIndex: -1 };
+  }
+
+  anyItemWithConstantFieldHasRedirects(): {
+    found: boolean;
+    itemIndex: number;
+  } {
+    for (let i = 0; i < this._itemList.count; i++) {
+      const item = this._itemList.get(i);
+      if (item.hasConstantFieldAndHasRedirects()) {
+        return { found: true, itemIndex: i };
+      }
+    }
+    return { found: false, itemIndex: -1 };
+  }
+}

package/src/meta/sequences/redirects/ft-boolean-meta-sequence-redirect.ts

@@ -0,0 +1,49 @@
+// Boolean meta sequence redirect
+
+import { FtSequenceRedirectType } from '../../../types/enums/ft-sequence-redirect-type.js';
+import type { FtMetaSequenceList } from '../core/ft-meta-sequence-list.js';
+import { FtMetaSequenceRedirect } from './ft-meta-sequence-redirect.js';
+
+/**
+ * Meta sequence redirect that triggers when a field value matches a specific boolean value.
+ * Used in metadata to define sequence transitions based on boolean field values.
+ * @public
+ */
+export class FtBooleanMetaSequenceRedirect extends FtMetaSequenceRedirect {
+  /** The standard type identifier for boolean redirects */
+  static readonly TYPE = FtSequenceRedirectType.Boolean;
+  /** Default boolean value */
+  static readonly DEFAULT_VALUE = false;
+
+  private _value: boolean;
+
+  constructor() {
+    super(FtBooleanMetaSequenceRedirect.TYPE);
+    this._value = FtBooleanMetaSequenceRedirect.DEFAULT_VALUE;
+  }
+
+  /** The boolean value to match for triggering the redirect */
+  get value(): boolean {
+    return this._value;
+  }
+
+  set value(val: boolean) {
+    this._value = val;
+  }
+
+  override loadDefaults(): void {
+    super.loadDefaults();
+    this._value = FtBooleanMetaSequenceRedirect.DEFAULT_VALUE;
+  }
+
+  createCopy(sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): FtMetaSequenceRedirect {
+    const redirect = new FtBooleanMetaSequenceRedirect();
+    redirect.assign(this, sequenceList, sourceSequenceList);
+    return redirect;
+  }
+
+  protected override assign(source: FtMetaSequenceRedirect, sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): void {
+    super.assign(source, sequenceList, sourceSequenceList);
+    this._value = (source as FtBooleanMetaSequenceRedirect)._value;
+  }
+}

package/src/meta/sequences/redirects/ft-case-insensitive-string-meta-sequence-redirect.ts

@@ -0,0 +1,49 @@
+// Case-insensitive string meta sequence redirect
+
+import { FtSequenceRedirectType } from '../../../types/enums/ft-sequence-redirect-type.js';
+import type { FtMetaSequenceList } from '../core/ft-meta-sequence-list.js';
+import { FtMetaSequenceRedirect } from './ft-meta-sequence-redirect.js';
+
+/**
+ * Meta sequence redirect that triggers when a field value matches a specific string (case-insensitive).
+ * Used in metadata to define sequence transitions based on string field values without case sensitivity.
+ * @public
+ */
+export class FtCaseInsensitiveStringMetaSequenceRedirect extends FtMetaSequenceRedirect {
+  /** The standard type identifier for case-insensitive string redirects */
+  static readonly TYPE = FtSequenceRedirectType.CaseInsensitiveString;
+  /** Default string value */
+  static readonly DEFAULT_VALUE = '';
+
+  private _value: string;
+
+  constructor() {
+    super(FtCaseInsensitiveStringMetaSequenceRedirect.TYPE);
+    this._value = FtCaseInsensitiveStringMetaSequenceRedirect.DEFAULT_VALUE;
+  }
+
+  /** The string value to match (case-insensitive) for triggering the redirect */
+  get value(): string {
+    return this._value;
+  }
+
+  set value(val: string) {
+    this._value = val;
+  }
+
+  override loadDefaults(): void {
+    super.loadDefaults();
+    this._value = FtCaseInsensitiveStringMetaSequenceRedirect.DEFAULT_VALUE;
+  }
+
+  createCopy(sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): FtMetaSequenceRedirect {
+    const redirect = new FtCaseInsensitiveStringMetaSequenceRedirect();
+    redirect.assign(this, sequenceList, sourceSequenceList);
+    return redirect;
+  }
+
+  protected override assign(source: FtMetaSequenceRedirect, sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): void {
+    super.assign(source, sequenceList, sourceSequenceList);
+    this._value = (source as FtCaseInsensitiveStringMetaSequenceRedirect)._value;
+  }
+}

package/src/meta/sequences/redirects/ft-date-meta-sequence-redirect.ts

@@ -0,0 +1,54 @@
+// Date meta sequence redirect
+
+import { FtSequenceRedirectType } from '../../../types/enums/ft-sequence-redirect-type.js';
+import type { FtMetaSequenceList } from '../core/ft-meta-sequence-list.js';
+import { FtMetaSequenceRedirect } from './ft-meta-sequence-redirect.js';
+
+/**
+ * Meta sequence redirect that triggers when a field's date part matches a specific date (ignoring time).
+ * Used in metadata to define sequence transitions based on date field values (time component ignored).
+ * @public
+ */
+export class FtDateMetaSequenceRedirect extends FtMetaSequenceRedirect {
+  /** The standard type identifier for date redirects */
+  static readonly TYPE = FtSequenceRedirectType.Date;
+  /** Default date value (Unix epoch) */
+  static readonly DEFAULT_VALUE = new Date(0);
+
+  private _value: Date;
+
+  constructor() {
+    super(FtDateMetaSequenceRedirect.TYPE);
+    this._value = new Date(FtDateMetaSequenceRedirect.DEFAULT_VALUE);
+  }
+
+  /** The date value to match (time component ignored) for triggering the redirect */
+  get value(): Date {
+    return this._value;
+  }
+
+  set value(val: Date) {
+    // Store only the date part (set time to midnight)
+    const dateOnly = new Date(val);
+    dateOnly.setHours(0, 0, 0, 0);
+    this._value = dateOnly;
+  }
+
+  override loadDefaults(): void {
+    super.loadDefaults();
+    const dateOnly = new Date(FtDateMetaSequenceRedirect.DEFAULT_VALUE);
+    dateOnly.setHours(0, 0, 0, 0);
+    this._value = dateOnly;
+  }
+
+  createCopy(sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): FtMetaSequenceRedirect {
+    const redirect = new FtDateMetaSequenceRedirect();
+    redirect.assign(this, sequenceList, sourceSequenceList);
+    return redirect;
+  }
+
+  protected override assign(source: FtMetaSequenceRedirect, sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): void {
+    super.assign(source, sequenceList, sourceSequenceList);
+    this._value = new Date((source as FtDateMetaSequenceRedirect)._value);
+  }
+}

package/src/meta/sequences/redirects/ft-exact-date-time-meta-sequence-redirect.ts

@@ -0,0 +1,49 @@
+// Exact date-time meta sequence redirect
+
+import { FtSequenceRedirectType } from '../../../types/enums/ft-sequence-redirect-type.js';
+import type { FtMetaSequenceList } from '../core/ft-meta-sequence-list.js';
+import { FtMetaSequenceRedirect } from './ft-meta-sequence-redirect.js';
+
+/**
+ * Meta sequence redirect that triggers when a field value exactly matches a specific date-time value.
+ * Used in metadata to define sequence transitions based on exact date-time field values (including time component).
+ * @public
+ */
+export class FtExactDateTimeMetaSequenceRedirect extends FtMetaSequenceRedirect {
+  /** The standard type identifier for exact date-time redirects */
+  static readonly TYPE = FtSequenceRedirectType.ExactDateTime;
+  /** Default date-time value (Unix epoch) */
+  static readonly DEFAULT_VALUE = new Date(0);
+
+  private _value: Date;
+
+  constructor() {
+    super(FtExactDateTimeMetaSequenceRedirect.TYPE);
+    this._value = new Date(FtExactDateTimeMetaSequenceRedirect.DEFAULT_VALUE);
+  }
+
+  /** The date-time value to match exactly for triggering the redirect */
+  get value(): Date {
+    return this._value;
+  }
+
+  set value(val: Date) {
+    this._value = val;
+  }
+
+  override loadDefaults(): void {
+    super.loadDefaults();
+    this._value = new Date(FtExactDateTimeMetaSequenceRedirect.DEFAULT_VALUE);
+  }
+
+  createCopy(sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): FtMetaSequenceRedirect {
+    const redirect = new FtExactDateTimeMetaSequenceRedirect();
+    redirect.assign(this, sequenceList, sourceSequenceList);
+    return redirect;
+  }
+
+  protected override assign(source: FtMetaSequenceRedirect, sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): void {
+    super.assign(source, sequenceList, sourceSequenceList);
+    this._value = new Date((source as FtExactDateTimeMetaSequenceRedirect)._value);
+  }
+}

package/src/meta/sequences/redirects/ft-exact-decimal-meta-sequence-redirect.ts

@@ -0,0 +1,49 @@
+// Exact decimal meta sequence redirect
+
+import { FtSequenceRedirectType } from '../../../types/enums/ft-sequence-redirect-type.js';
+import type { FtMetaSequenceList } from '../core/ft-meta-sequence-list.js';
+import { FtMetaSequenceRedirect } from './ft-meta-sequence-redirect.js';
+
+/**
+ * Meta sequence redirect that triggers when a field value exactly matches a specific decimal value.
+ * Used in metadata to define sequence transitions based on decimal field values.
+ * @public
+ */
+export class FtExactDecimalMetaSequenceRedirect extends FtMetaSequenceRedirect {
+  /** The standard type identifier for exact decimal redirects */
+  static readonly TYPE = FtSequenceRedirectType.ExactDecimal;
+  /** Default decimal value */
+  static readonly DEFAULT_VALUE = 0;
+
+  private _value: number;
+
+  constructor() {
+    super(FtExactDecimalMetaSequenceRedirect.TYPE);
+    this._value = FtExactDecimalMetaSequenceRedirect.DEFAULT_VALUE;
+  }
+
+  /** The decimal value to match exactly for triggering the redirect */
+  get value(): number {
+    return this._value;
+  }
+
+  set value(val: number) {
+    this._value = val;
+  }
+
+  override loadDefaults(): void {
+    super.loadDefaults();
+    this._value = FtExactDecimalMetaSequenceRedirect.DEFAULT_VALUE;
+  }
+
+  createCopy(sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): FtMetaSequenceRedirect {
+    const redirect = new FtExactDecimalMetaSequenceRedirect();
+    redirect.assign(this, sequenceList, sourceSequenceList);
+    return redirect;
+  }
+
+  protected override assign(source: FtMetaSequenceRedirect, sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): void {
+    super.assign(source, sequenceList, sourceSequenceList);
+    this._value = (source as FtExactDecimalMetaSequenceRedirect)._value;
+  }
+}

package/src/meta/sequences/redirects/ft-exact-float-meta-sequence-redirect.ts

@@ -0,0 +1,49 @@
+// Exact float meta sequence redirect
+
+import { FtSequenceRedirectType } from '../../../types/enums/ft-sequence-redirect-type.js';
+import type { FtMetaSequenceList } from '../core/ft-meta-sequence-list.js';
+import { FtMetaSequenceRedirect } from './ft-meta-sequence-redirect.js';
+
+/**
+ * Meta sequence redirect that triggers when a field value exactly matches a specific float value.
+ * Used in metadata to define sequence transitions based on floating-point field values.
+ * @public
+ */
+export class FtExactFloatMetaSequenceRedirect extends FtMetaSequenceRedirect {
+  /** The standard type identifier for exact float redirects */
+  static readonly TYPE = FtSequenceRedirectType.ExactFloat;
+  /** Default float value */
+  static readonly DEFAULT_VALUE = 0;
+
+  private _value: number;
+
+  constructor() {
+    super(FtExactFloatMetaSequenceRedirect.TYPE);
+    this._value = FtExactFloatMetaSequenceRedirect.DEFAULT_VALUE;
+  }
+
+  /** The float value to match exactly for triggering the redirect */
+  get value(): number {
+    return this._value;
+  }
+
+  set value(val: number) {
+    this._value = val;
+  }
+
+  override loadDefaults(): void {
+    super.loadDefaults();
+    this._value = FtExactFloatMetaSequenceRedirect.DEFAULT_VALUE;
+  }
+
+  createCopy(sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): FtMetaSequenceRedirect {
+    const redirect = new FtExactFloatMetaSequenceRedirect();
+    redirect.assign(this, sequenceList, sourceSequenceList);
+    return redirect;
+  }
+
+  protected override assign(source: FtMetaSequenceRedirect, sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): void {
+    super.assign(source, sequenceList, sourceSequenceList);
+    this._value = (source as FtExactFloatMetaSequenceRedirect)._value;
+  }
+}

package/src/meta/sequences/redirects/ft-exact-integer-meta-sequence-redirect.ts

@@ -0,0 +1,49 @@
+// Exact integer meta sequence redirect
+
+import { FtSequenceRedirectType } from '../../../types/enums/ft-sequence-redirect-type.js';
+import type { FtMetaSequenceList } from '../core/ft-meta-sequence-list.js';
+import { FtMetaSequenceRedirect } from './ft-meta-sequence-redirect.js';
+
+/**
+ * Meta sequence redirect that triggers when a field value exactly matches a specific integer value.
+ * Used in metadata to define sequence transitions based on integer field values.
+ * @public
+ */
+export class FtExactIntegerMetaSequenceRedirect extends FtMetaSequenceRedirect {
+  /** The standard type identifier for exact integer redirects */
+  static readonly TYPE = FtSequenceRedirectType.ExactInteger;
+  /** Default integer value */
+  static readonly DEFAULT_VALUE = 0n;
+
+  private _value: bigint;
+
+  constructor() {
+    super(FtExactIntegerMetaSequenceRedirect.TYPE);
+    this._value = FtExactIntegerMetaSequenceRedirect.DEFAULT_VALUE;
+  }
+
+  /** The integer value to match exactly for triggering the redirect */
+  get value(): bigint {
+    return this._value;
+  }
+
+  set value(val: bigint) {
+    this._value = val;
+  }
+
+  override loadDefaults(): void {
+    super.loadDefaults();
+    this._value = FtExactIntegerMetaSequenceRedirect.DEFAULT_VALUE;
+  }
+
+  createCopy(sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): FtMetaSequenceRedirect {
+    const redirect = new FtExactIntegerMetaSequenceRedirect();
+    redirect.assign(this, sequenceList, sourceSequenceList);
+    return redirect;
+  }
+
+  protected override assign(source: FtMetaSequenceRedirect, sequenceList: FtMetaSequenceList, sourceSequenceList: FtMetaSequenceList): void {
+    super.assign(source, sequenceList, sourceSequenceList);
+    this._value = (source as FtExactIntegerMetaSequenceRedirect)._value;
+  }
+}