@pbkware/fielded-text-web 0.1.0 → 0.2.1

package/src/meta-serialization/utils/sequence-item-field-indices.ts

@@ -1,7 +1,7 @@
-import { CommaText } from '@pbkware/js-utils';
 import { FtMetaFieldList } from '../../meta/fields/ft-meta-field-list.js';
 import { FtMetaField } from '../../meta/fields/ft-meta-field.js';
 import { FtMetaSequence } from '../../meta/sequences/core/ft-meta-sequence.js';
+import { FtCommaText } from '../../utils/ft-comma-text.js';
 import { IntegerFloatMetaSerialization } from '../types/integer-float-meta-serialization.js';
 
 export namespace SequenceItemFieldIndexSerialization {
@@ -27,7 +27,7 @@ export namespace SequenceItemFieldIndexSerialization {
     }
     fieldIndices.length = count; // Trim to actual count
 
-    const commaTextFieldIndices = count > 0 ? CommaText.fromIntegerArray(fieldIndices) : undefined;
+    const commaTextFieldIndices = count > 0 ? FtCommaText.fromIntegerArray(fieldIndices) : undefined;
 
     return {
       commaTextFieldIndices,

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

@@ -13,6 +13,7 @@ export class FtCaseInsensitiveStringSequenceRedirect extends FtSequenceRedirect
   static readonly TYPE = FtSequenceRedirectType.CaseInsensitiveString;
 
   private _value = '';
+  private _lowerCaseValue = '';
 
   constructor(index: number) {
     super(index, FtCaseInsensitiveStringSequenceRedirect.TYPE);
@@ -27,7 +28,7 @@ export class FtCaseInsensitiveStringSequenceRedirect extends FtSequenceRedirect
       return false;
     }
     try {
-      return field.asRedirectString.toLowerCase() === this._value.toLowerCase();
+      return field.asRedirectString.toLowerCase() === this._lowerCaseValue;
     } catch {
       return false;
     }
@@ -42,5 +43,6 @@ export class FtCaseInsensitiveStringSequenceRedirect extends FtSequenceRedirect
     super.loadMeta(metaSequenceRedirect, metaSequenceList, sequenceList);
 
     this._value = metaSequenceRedirect.value;
+    this._lowerCaseValue = this._value.toLowerCase();
   }
 }

package/src/serialization/char-reader.ts

@@ -1,5 +1,5 @@
-import { FtUnreachableCaseError } from '../types/errors/ft-internal-error.js';
-import { FtTextReader } from './ft-text-reader.js';
+import { FtUnreachableCaseError } from '../utils/ft-internal-error.js';
+import { FtTextReader } from './text-reader/ft-text-reader.js';
 
 const State = {
   Read: 'Read',

package/src/serialization/declaration-parser.ts

@@ -1,4 +1,4 @@
-import { FtUnreachableCaseError } from '../types/errors/ft-internal-error.js';
+import { FtUnreachableCaseError } from '../utils/ft-internal-error.js';
 import { CharReader } from './char-reader.js';
 import { FtDeclaredParameters } from './ft-declared-parameters.js';
 

package/src/serialization/delimited-field-parser.ts

@@ -1,7 +1,7 @@
 import { FtField } from '../fields/instances/ft-field.js';
 import { FtQuotedType } from '../types/enums/ft-quoted-type.js';
 import { CharReader } from './char-reader.js';
-import { SerializationCore } from './serialization-core.js';
+import { FtSerializationCore } from './ft-serialization-core.js';
 
 const QuotedState = {
   NeverOpen: 'NeverOpen',
@@ -23,7 +23,7 @@ type QuotedState = (typeof QuotedState)[keyof typeof QuotedState];
 export class DelimitedFieldParser {
   private readonly _headings: boolean;
   private readonly _charReader: CharReader;
-  private readonly _core: SerializationCore;
+  private readonly _core: FtSerializationCore;
   private _textBuilder: string[] = [];
 
   private _field: FtField | undefined = undefined;
@@ -39,7 +39,7 @@ export class DelimitedFieldParser {
   private _rawOffset = -1;
   private _rawLength = 0;
 
-  constructor(core: SerializationCore, charReader: CharReader, forHeadings: boolean) {
+  constructor(core: FtSerializationCore, charReader: CharReader, forHeadings: boolean) {
     this._headings = forHeadings;
     this._charReader = charReader;
     this._core = core;

package/src/serialization/fixed-width-field-parser.ts

@@ -1,8 +1,8 @@
 import { FtField } from '../fields/instances/ft-field.js';
 import { FtPadCharType } from '../types/enums/ft-pad-char-type.js';
-import { FtAssertError, FtUnreachableCaseError } from '../types/errors/ft-internal-error.js';
+import { FtAssertError, FtUnreachableCaseError } from '../utils/ft-internal-error.js';
 import { CharReader } from './char-reader.js';
-import { SerializationCore } from './serialization-core.js';
+import { FtSerializationCore } from './ft-serialization-core.js';
 
 const State = {
   WaitingLeftEndOfValue: 'WaitingLeftEndOfValue',
@@ -24,7 +24,7 @@ type State = (typeof State)[keyof typeof State];
 export class FixedWidthFieldParser {
   private readonly _headings: boolean;
   private readonly _charReader: CharReader;
-  private readonly _core: SerializationCore;
+  private readonly _core: FtSerializationCore;
   private _textBuilder: string[] = [];
 
   private _state: State = State.NoMorePadding;
@@ -42,7 +42,7 @@ export class FixedWidthFieldParser {
   private _fieldPadChar = '';
   private _rightPaddingCharCount = 0;
 
-  constructor(core: SerializationCore, charReader: CharReader, forHeadings: boolean) {
+  constructor(core: FtSerializationCore, charReader: CharReader, forHeadings: boolean) {
     this._headings = forHeadings;
     this._charReader = charReader;
     this._core = core;

package/src/serialization/ft-declared-parameters.ts

@@ -1,6 +1,7 @@
-import { Err, isStringifiedInteger, Ok, Result } from '@pbkware/js-utils';
 import { FtMetaReferenceType } from '../types/enums/ft-meta-reference-type.js';
-import { FtUnreachableCaseError } from '../types/errors/ft-internal-error.js';
+import { FtUnreachableCaseError } from '../utils/ft-internal-error.js';
+import { FtErr, FtOk, FtResult } from '../utils/ft-result.js';
+import { isStringifiedInteger } from '../utils/number-parse.js';
 
 /**
  * Parameter record for declared parameters.
@@ -82,12 +83,12 @@ export class FtDeclaredParameters {
     this.add(FtDeclaredParameters.VERSION_PARAMETER_NAME, this.versionToText(major, minor, comment));
   }
 
-  tryGetVersion(): Result<Version, boolean> {
+  tryGetVersion(): FtResult<Version, boolean> {
     const idx = this.indexOfVersion();
     if (idx >= 0) {
       return this.parseVersionValue(this._list[idx].value);
     } else {
-      return new Err(false);
+      return new FtErr(false);
     }
   }
 
@@ -173,10 +174,10 @@ export class FtDeclaredParameters {
     }
   }
 
-  private parseVersionValue(text: string): Result<Version, boolean> {
+  private parseVersionValue(text: string): FtResult<Version, boolean> {
     const majorMinorSeparatorIdx = text.indexOf(FtDeclaredParameters.VERSION_PARTS_SEPARATOR);
     if (majorMinorSeparatorIdx <= 0 || majorMinorSeparatorIdx >= text.length - 1) {
-      return new Err(false);
+      return new FtErr(false);
     }
 
     let minorCommentSeparatorIdx = text.indexOf(FtDeclaredParameters.VERSION_PARTS_SEPARATOR, majorMinorSeparatorIdx + 1);
@@ -204,22 +205,22 @@ export class FtDeclaredParameters {
       return minorResult.createType();
     }
 
-    return new Ok({
+    return new FtOk({
       major: majorResult.value,
       minor: minorResult.value,
       comment,
     });
   }
 
-  private parseMajorMinorVersionText(text: string): Result<number, boolean> {
+  private parseMajorMinorVersionText(text: string): FtResult<number, boolean> {
     if (!isStringifiedInteger(text)) {
-      return new Err(false);
+      return new FtErr(false);
     } else {
       const result = parseInt(text, 10);
       if (Number.isNaN(result)) {
-        return new Err(false);
+        return new FtErr(false);
       } else {
-        return new Ok(result);
+        return new FtOk(result);
       }
     }
   }

package/src/serialization/{serialization-core.ts → ft-serialization-core.ts}

@@ -19,22 +19,22 @@ import { FtQuotedType } from '../types/enums/ft-quoted-type.js';
 import { FtSequenceInvokationDelay } from '../types/enums/ft-sequence-invokation-delay.js';
 import { FtSubstitutionType } from '../types/enums/ft-substitution-type.js';
 import { FtTruncateType } from '../types/enums/ft-truncate-type.js';
-import { FtUnreachableCaseError } from '../types/errors/ft-internal-error.js';
-import { FtFieldHeadingReadyEventArgs } from '../types/events/ft-field-heading-ready-event-args.js';
-import { FtFieldValueReadyEventArgs } from '../types/events/ft-field-value-ready-event-args.js';
-import { FtHeadingLineFinishedEventArgs } from '../types/events/ft-heading-line-finished-event-args.js';
-import { FtHeadingLineStartedEventArgs } from '../types/events/ft-heading-line-started-event-args.js';
-import { FtRecordFinishedEventArgs } from '../types/events/ft-record-finished-event-args.js';
-import { FtRecordStartedEventArgs } from '../types/events/ft-record-started-event-args.js';
-import { FtSequenceRedirectedEventArgs } from '../types/events/ft-sequence-redirected-event-args.js';
+import { FtUnreachableCaseError } from '../utils/ft-internal-error.js';
 import { CharReader } from './char-reader.js';
+import { FtFieldHeadingReadyEventArgs } from './events/ft-field-heading-ready-event-args.js';
+import { FtFieldValueReadyEventArgs } from './events/ft-field-value-ready-event-args.js';
+import { FtHeadingLineFinishedEventArgs } from './events/ft-heading-line-finished-event-args.js';
+import { FtHeadingLineStartedEventArgs } from './events/ft-heading-line-started-event-args.js';
+import { FtRecordFinishedEventArgs } from './events/ft-record-finished-event-args.js';
+import { FtRecordStartedEventArgs } from './events/ft-record-started-event-args.js';
+import { FtSequenceRedirectedEventArgs } from './events/ft-sequence-redirected-event-args.js';
 
 /**
  * Base class for serialization (reading/writing).
  * Manages configuration, field lists, sequences, and events.
  * @public
  */
-export abstract class SerializationCore {
+export abstract class FtSerializationCore {
   static readonly VersionMajor = 1;
   static readonly VersionMinor = 1;
   static readonly PrefixSpaceChar = ' ';
@@ -227,38 +227,154 @@ export abstract class SerializationCore {
     return this._headingEndOfValueChar;
   }
 
-  // IDataReader-like interface
+  /**
+   * Number of fields in the current record.
+   *
+   * IDataReader member
+   */
   get fieldCount(): number {
     return this._fieldList.count;
   }
 
+  /**
+   * Number of sequences currently invoked (depth of sequence invokation stack).
+   *
+   * IDataReader member
+   */
   get depth(): number {
     return this._sequenceInvokationList.count;
   }
 
+  /**
+   * Whether the reader/writer is closed.
+   *
+   * IDataReader member
+   */
   abstract get isClosed(): boolean;
 
+  /**
+   * Name of the field at the given index.
+   * Alias for {@link getFieldName}.
+   *
+   * IDataReader member
+   */
   getName(idx: number): string {
     return this._fieldList.get(idx).name;
   }
 
+  /**
+   * Get a index of field in record by its name.
+   *
+   * IDataReader member
+   * @throws Error if the field is not found.
+   */
   getOrdinal(name: string): number {
+    const result = this.getFieldIndexByName(name);
+    if (result === undefined) {
+      throw new Error(`Field not found: ${name}`);
+    } else {
+      return result;
+    }
+  }
+
+  /**
+   * Whether the field value at the given index is null.
+   * Alias for {@link isFieldNull}.
+   *
+   * IDataReader member
+   */
+  isDBNull(idx: number): boolean {
+    return this.isFieldNull(idx);
+  }
+
+  /**
+   * Get a FtField object at index.
+   */
+  getField(idx: number): FtField {
+    return this._fieldList.get(idx);
+  }
+
+  /**
+   * Get a FtField object by name.
+   */
+  getFieldByName(name: string): FtField | undefined {
+    return this._fieldList.getByName(name);
+  }
+
+  /**
+   * Get a index of field in record by its name.
+   * @throws Error if the field is not found.
+   */
+  getFieldIndexByName(name: string): number | undefined {
     const result = this._fieldList.indexOfName(name);
     if (result >= 0) {
       return result;
     } else {
-      throw new Error(`Field not found: ${name}`);
+      return undefined;
     }
   }
 
-  getValueType(idx: number): string {
-    return this._fieldList.get(idx).valueType;
+  /**
+   * Get the name of the field at the given index.
+   */
+  getFieldName(idx: number): string {
+    return this._fieldList.get(idx).name;
   }
 
-  isDBNull(idx: number): boolean {
+  /**
+   * Get a field value by index.
+   * @throws FtFieldNullError if the field value is null.
+   */
+  getFieldValue(idx: number): FtField.Value | null {
+    return this._fieldList.get(idx).value;
+  }
+
+  /**
+   * Whether the field value at the given index is null.
+   */
+  isFieldNull(idx: number): boolean {
     return this._fieldList.get(idx).isNull();
   }
 
+  /**
+   * Get the value type of the field at the given index.
+   */
+  getFieldValueType(idx: number): string {
+    return this._fieldList.get(idx).valueType;
+  }
+
+  /**
+   * Get a field value by index. Returns `null` if the field value is null.
+   */
+  getFieldNullableValue(idx: number): FtField.Value | null {
+    return this._fieldList.get(idx).nullableValue;
+  }
+
+  /**
+   * Get a field value by name.
+   * @throws FtFieldNullError if the field value is null.
+   * @throws Error if the field is not found.
+   */
+  getFieldValueByName(name: string): FtField.Value | null {
+    const field = this._fieldList.getByName(name);
+    if (!field) {
+      throw new Error(`Field not found: ${name}`);
+    }
+    return field.value;
+  }
+
+  /**
+   * Get a field value by name. Returns `null` if the field value is null.
+   * @throws Error if the field is not found.
+   */
+  getFieldNullableValueByName(name: string): FtField.Value | null {
+    const field = this._fieldList.getByName(name);
+    if (!field) {
+      throw new Error(`Field not found: ${name}`);
+    }
+    return field.nullableValue;
+  }
+
   tryGetSubstitutionValue(token: string): { found: boolean; value: string } {
     return this._substitutionList.tryGetValue(token);
   }
@@ -616,11 +732,11 @@ export abstract class SerializationCore {
   private calculateAutoEndOfLineSubstitutionValue(): string {
     switch (this._endOfLineAutoWriteType) {
       case FtEndOfLineAutoWriteType.CrLf:
-        return SerializationCore.CarriageReturnLineFeedString;
+        return FtSerializationCore.CarriageReturnLineFeedString;
       case FtEndOfLineAutoWriteType.Cr:
-        return SerializationCore.CarriageReturnChar;
+        return FtSerializationCore.CarriageReturnChar;
       case FtEndOfLineAutoWriteType.Lf:
-        return SerializationCore.LineFeedChar;
+        return FtSerializationCore.LineFeedChar;
       case FtEndOfLineAutoWriteType.Local:
         return '\n';
       default:

package/src/{types/errors/ft-serialization-error.ts → serialization/ft-serialization-error-code.ts}

@@ -2,7 +2,7 @@
  * Enumeration of serialization error codes.
  * @public
  */
-export const FtSerializationError = {
+export const FtSerializationErrorCode = {
   Abort: 'Abort',
   DeclarationParameterNameIsZeroLength: 'DeclarationParameterNameIsZeroLength',
   DeclaredParameterNameContainsSeparator: 'DeclaredParameterNameContainsSeparator',
@@ -50,4 +50,4 @@ export const FtSerializationError = {
 /**
  * @public
  */
-export type FtSerializationError = (typeof FtSerializationError)[keyof typeof FtSerializationError];
+export type FtSerializationErrorCode = (typeof FtSerializationErrorCode)[keyof typeof FtSerializationErrorCode];

package/src/{types/errors/ft-serialization-exception.ts → serialization/ft-serialization-error.ts}

@@ -1,18 +1,23 @@
-import { FtField } from '../../fields/instances/ft-field.js';
-import { FtSerializationError } from './ft-serialization-error.js';
+import { FtField } from '../fields/instances/ft-field.js';
+import { FtSerializationErrorCode } from './ft-serialization-error-code.js';
 
 /**
  * Exception thrown during fielded text serialization/deserialization.
  * @public
  */
-export class FtSerializationException extends Error {
-  private readonly _error: FtSerializationError;
+export class FtSerializationError extends Error {
+  private readonly _error: FtSerializationErrorCode;
   private readonly _fieldName: string | undefined;
   private readonly _fieldIndex: number;
   private readonly _sequenceName: string | undefined;
   private readonly _sequenceItemIndex: number;
 
-  constructor(error: FtSerializationError, fieldOrMessage: FtField | string | undefined, messageOrInner?: string | Error, innerException?: Error) {
+  constructor(
+    errorCode: FtSerializationErrorCode,
+    fieldOrMessage: FtField | string | undefined,
+    messageOrInner?: string | Error,
+    innerException?: Error,
+  ) {
     let message: string;
     let field: FtField | undefined = undefined;
     let inner: Error | undefined = undefined;
@@ -38,12 +43,12 @@ export class FtSerializationException extends Error {
       }
     }
 
-    const errorName = FtSerializationError[error];
+    const errorName = FtSerializationErrorCode[errorCode];
     const fullMessage = errorName + (message ? ': ' + message : '');
     super(fullMessage);
 
-    this.name = 'FtSerializationException';
-    this._error = error;
+    this.name = 'FtSerializationError';
+    this._error = errorCode;
 
     if (field === undefined) {
       this._fieldName = undefined;
@@ -64,7 +69,7 @@ export class FtSerializationException extends Error {
     }
   }
 
-  get error(): FtSerializationError {
+  get error(): FtSerializationErrorCode {
     return this._error;
   }
 

package/src/serialization/ft-serialization-reader.ts

@@ -1,4 +1,3 @@
-import { FtField } from '../fields/instances/ft-field.js';
 import { FtMetaSerialization } from '../meta-serialization/ft-meta-serialization.js';
 import { FtMeta } from '../meta/ft-meta.js';
 import { FtLastLineEndedType } from '../types/enums/ft-last-line-ended-type.js';
@@ -6,23 +5,23 @@ import { FtLineType } from '../types/enums/ft-line-type.js';
 import { FtMetaReferenceType } from '../types/enums/ft-meta-reference-type.js';
 import { FtMetaSerializationFormat } from '../types/enums/ft-meta-serialization-format.js';
 import { FtReadRecordResult } from '../types/enums/ft-read-record-result.js';
-import { FtUnreachableCaseError } from '../types/errors/ft-internal-error.js';
-import { FtSerializationError } from '../types/errors/ft-serialization-error.js';
-import { FtSerializationException } from '../types/errors/ft-serialization-exception.js';
+import { FtUnreachableCaseError } from '../utils/ft-internal-error.js';
 import { CharReader } from './char-reader.js';
 import { DeclarationParser } from './declaration-parser.js';
 import { EmbeddedMetaParser } from './embedded-meta-parser.js';
 import { FtDeclaredParameters } from './ft-declared-parameters.js';
-import { FtTextReader } from './ft-text-reader.js';
+import { FtSerializationCore } from './ft-serialization-core.js';
+import { FtSerializationErrorCode } from './ft-serialization-error-code.js';
+import { FtSerializationError } from './ft-serialization-error.js';
 import { HeadingLineRecordParser } from './heading-line-record-parser.js';
 import { LineEndedType, LineParser } from './line-parser.js';
-import { SerializationCore } from './serialization-core.js';
+import { FtTextReader } from './text-reader/ft-text-reader.js';
 
 /**
  * Reader for fielded text streams. Coordinates all parsing components.
  * @public
  */
-export class FtSerializationReader extends SerializationCore {
+export class FtSerializationReader extends FtSerializationCore {
   /**
    * Event fired when seeking through records.
    */
@@ -396,38 +395,6 @@ export class FtSerializationReader extends SerializationCore {
     }
   }
 
-  /**
-   * Get a field object by index.
-   */
-  getField(idx: number): FtField {
-    return this.fieldList.get(idx);
-  }
-
-  /**
-   * Get a field object by name.
-   */
-  getFieldByName(name: string): FtField | undefined {
-    return this.fieldList.getByName(name);
-  }
-
-  /**
-   * Get a field value by index.
-   */
-  getFieldValue(idx: number): unknown {
-    return this.fieldList.get(idx).asObject;
-  }
-
-  /**
-   * Get a field value by name.
-   */
-  getFieldValueByName(name: string): unknown {
-    const field = this.fieldList.getByName(name);
-    if (!field) {
-      throw new Error(`Field not found: ${name}`);
-    }
-    return field.asObject;
-  }
-
   /**
    * Load metadata from a pre-parsed FtMeta object.
    * @param meta - The metadata to load.
@@ -483,8 +450,8 @@ export class FtSerializationReader extends SerializationCore {
   protected getFileMetaAsText(fileMetaReference: string): FtSerializationReader.FileMetaAsTextResult | string {
     // Descendants can override this method. Clients can subscribe to onRequireFileMetaAsText event
     if (!this.onRequireFileMetaAsText) {
-      throw new FtSerializationException(
-        FtSerializationError.MetaReferenceFileNoHandler,
+      throw new FtSerializationError(
+        FtSerializationErrorCode.MetaReferenceFileNoHandler,
         'Meta reference is file but no handler provided to retrieve file content',
       );
     } else {
@@ -495,8 +462,8 @@ export class FtSerializationReader extends SerializationCore {
   protected getUrlMetaAsText(urlMetaReference: string): FtSerializationReader.FileMetaAsTextResult | string {
     // Descendants can override this method. Clients can subscribe to onRequireUrlMetaAsText event
     if (!this.onRequireUrlMetaAsText) {
-      throw new FtSerializationException(
-        FtSerializationError.MetaReferenceUrlNoHandler,
+      throw new FtSerializationError(
+        FtSerializationErrorCode.MetaReferenceUrlNoHandler,
         'Meta reference is URL but no handler provided to retrieve URL content',
       );
     } else {
@@ -609,7 +576,7 @@ export class FtSerializationReader extends SerializationCore {
               // Must be a heading line
               this._lineType = FtLineType.Heading;
               if (this._metaEmbedded && !this._embeddedMetaRead) {
-                throw new FtSerializationException(FtSerializationError.EmbeddedMetaNotFound, 'Embedded meta line not blank or comment');
+                throw new FtSerializationError(FtSerializationErrorCode.EmbeddedMetaNotFound, 'Embedded meta line not blank or comment');
               } else {
                 if (!(this.headingLineCount > 0 && !this._headingLinesRead)) {
                   throw new Error('Unexpected heading line state');
@@ -637,7 +604,7 @@ export class FtSerializationReader extends SerializationCore {
               this._recordParser.parseChar(aChar);
             } else {
               if (!this.ignoreBlankLines) {
-                throw new FtSerializationException(FtSerializationError.RecordNotEnoughFields, 'Blank records not allowed');
+                throw new FtSerializationError(FtSerializationErrorCode.RecordNotEnoughFields, 'Blank records not allowed');
               }
             }
           }
@@ -722,7 +689,7 @@ export class FtSerializationReader extends SerializationCore {
         this.finishLastLine();
 
         if (this.lastLineEndedType === FtLastLineEndedType.Always) {
-          throw new FtSerializationException(FtSerializationError.LastLineEndedError, 'Always ended but in line');
+          throw new FtSerializationError(FtSerializationErrorCode.LastLineEndedError, 'Always ended but in line');
         } else {
           this._lineParser.exitLine();
           result = true;
@@ -732,17 +699,17 @@ export class FtSerializationReader extends SerializationCore {
           result = false;
         } else {
           if (!this.ignoreBlankLines) {
-            throw new FtSerializationException(FtSerializationError.LastLineEndedError, 'Never ended but out of line');
+            throw new FtSerializationError(FtSerializationErrorCode.LastLineEndedError, 'Never ended but out of line');
           } else {
             // Since last line cannot be ended, there is another ignored blank line
 
             // Throw exception if blank line not allowed
             switch (this._lineType) {
               case FtLineType.Signature:
-                throw new FtSerializationException(FtSerializationError.IncompleteDeclaration, 'Declaration missing second line');
+                throw new FtSerializationError(FtSerializationErrorCode.IncompleteDeclaration, 'Declaration missing second line');
               case FtLineType.Heading:
                 if (!this._headingLinesRead) {
-                  throw new FtSerializationException(FtSerializationError.InsufficientHeadingLines, '');
+                  throw new FtSerializationError(FtSerializationErrorCode.InsufficientHeadingLines, '');
                 }
                 break;
             }
@@ -779,7 +746,7 @@ export class FtSerializationReader extends SerializationCore {
       case FtLineType.Comment:
         if (!this._headerRead) {
           if (this._metaEmbedded && !this._embeddedMetaRead) {
-            throw new FtSerializationException(FtSerializationError.EmbeddedMetaNotFound, 'End of file encountered');
+            throw new FtSerializationError(FtSerializationErrorCode.EmbeddedMetaNotFound, 'End of file encountered');
           }
         }
         break;
@@ -788,7 +755,7 @@ export class FtSerializationReader extends SerializationCore {
         if (this._embeddedMetaParser.ready) {
           this.finishEmbeddedMeta();
         } else {
-          throw new FtSerializationException(FtSerializationError.IncompleteEmbeddedMeta, 'End of file encountered');
+          throw new FtSerializationError(FtSerializationErrorCode.IncompleteEmbeddedMeta, 'End of file encountered');
         }
         break;
 
@@ -916,13 +883,13 @@ export class FtSerializationReader extends SerializationCore {
   private checkCompleteness(): void {
     if (!this._headerRead) {
       if (this._declared && !this._declarationRead) {
-        throw new FtSerializationException(FtSerializationError.IncompleteDeclaration, '');
+        throw new FtSerializationError(FtSerializationErrorCode.IncompleteDeclaration, '');
       } else {
         if (this._metaEmbedded && !this._embeddedMetaRead) {
-          throw new FtSerializationException(FtSerializationError.IncompleteEmbeddedMeta, '');
+          throw new FtSerializationError(FtSerializationErrorCode.IncompleteEmbeddedMeta, '');
         } else {
           if (this.headingLineCount > 0 && !this._headingLinesRead) {
-            throw new FtSerializationException(FtSerializationError.InsufficientHeadingLines, this._headingLineReadCount.toString());
+            throw new FtSerializationError(FtSerializationErrorCode.InsufficientHeadingLines, this._headingLineReadCount.toString());
           }
         }
       }