@glimmer/syntax/dist/modules/es2017/lib/source/loc/offset.js

// eslint-disable-next-line import/no-extraneous-dependencies
import { UNKNOWN_POSITION } from '../location';
import { match, MatchAny } from './match';
import { span } from './span';
/**
 * Used to indicate that an attempt to convert a `SourcePosition` to a character offset failed. It
 * is separate from `null` so that `null` can be used to indicate that the computation wasn't yet
 * attempted (and therefore to cache the failure)
 */

export const BROKEN = 'BROKEN';
/**
 * A `SourceOffset` represents a single position in the source.
 *
 * There are three kinds of backing data for `SourceOffset` objects:
 *
 * - `CharPosition`, which contains a character offset into the raw source string
 * - `HbsPosition`, which contains a `SourcePosition` from the Handlebars AST, which can be
 *   converted to a `CharPosition` on demand.
 * - `InvisiblePosition`, which represents a position not in source (@see {InvisiblePosition})
 */

export class SourceOffset {
  constructor(data) {
    this.data = data;
  }
  /**
   * Create a `SourceOffset` from a Handlebars `SourcePosition`. It's stored as-is, and converted
   * into a character offset on demand, which avoids unnecessarily computing the offset of every
   * `SourceLocation`, but also means that broken `SourcePosition`s are not always detected.
   */


  static forHbsPos(source, pos) {
    return new HbsPosition(source, pos, null).wrap();
  }
  /**
   * Create a `SourceOffset` that corresponds to a broken `SourcePosition`. This means that the
   * calling code determined (or knows) that the `SourceLocation` doesn't correspond correctly to
   * any part of the source.
   */


  static broken(pos = UNKNOWN_POSITION) {
    return new InvisiblePosition("Broken"
    /* Broken */
    , pos).wrap();
  }
  /**
   * Get the character offset for this `SourceOffset`, if possible.
   */


  get offset() {
    let charPos = this.data.toCharPos();
    return charPos === null ? null : charPos.offset;
  }
  /**
   * Compare this offset with another one.
   *
   * If both offsets are `HbsPosition`s, they're equivalent as long as their lines and columns are
   * the same. This avoids computing offsets unnecessarily.
   *
   * Otherwise, two `SourceOffset`s are equivalent if their successfully computed character offsets
   * are the same.
   */


  eql(right) {
    return eql(this.data, right.data);
  }
  /**
   * Create a span that starts from this source offset and ends with another source offset. Avoid
   * computing character offsets if both `SourceOffset`s are still lazy.
   */


  until(other) {
    return span(this.data, other.data);
  }
  /**
   * Create a `SourceOffset` by moving the character position represented by this source offset
   * forward or backward (if `by` is negative), if possible.
   *
   * If this `SourceOffset` can't compute a valid character offset, `move` returns a broken offset.
   *
   * If the resulting character offset is less than 0 or greater than the size of the source, `move`
   * returns a broken offset.
   */


  move(by) {
    let charPos = this.data.toCharPos();

    if (charPos === null) {
      return SourceOffset.broken();
    } else {
      let result = charPos.offset + by;

      if (charPos.source.check(result)) {
        return new CharPosition(charPos.source, result).wrap();
      } else {
        return SourceOffset.broken();
      }
    }
  }
  /**
   * Create a new `SourceSpan` that represents a collapsed range at this source offset. Avoid
   * computing the character offset if it has not already been computed.
   */


  collapsed() {
    return span(this.data, this.data);
  }
  /**
   * Convert this `SourceOffset` into a Handlebars {@see SourcePosition} for compatibility with
   * existing plugins.
   */


  toJSON() {
    return this.data.toJSON();
  }

}
export class CharPosition {
  constructor(source, charPos) {
    this.source = source;
    this.charPos = charPos;
    this.kind = "CharPosition"
    /* CharPosition */
    ;
    /** Computed from char offset */

    this._locPos = null;
  }
  /**
   * This is already a `CharPosition`.
   *
   * {@see HbsPosition} for the alternative.
   *
   * @implements {PositionData}
   */


  toCharPos() {
    return this;
  }
  /**
   * Produce a Handlebars {@see SourcePosition} for this `CharPosition`. If this `CharPosition` was
   * computed using {@see SourceOffset#move}, this will compute the `SourcePosition` for the offset.
   *
   * @implements {PositionData}
   */


  toJSON() {
    let hbs = this.toHbsPos();
    return hbs === null ? UNKNOWN_POSITION : hbs.toJSON();
  }

  wrap() {
    return new SourceOffset(this);
  }
  /**
   * A `CharPosition` always has an offset it can produce without any additional computation.
   */


  get offset() {
    return this.charPos;
  }
  /**
   * Convert the current character offset to an `HbsPosition`, if it was not already computed. Once
   * a `CharPosition` has computed its `HbsPosition`, it will not need to do compute it again, and
   * the same `CharPosition` is retained when used as one of the ends of a `SourceSpan`, so
   * computing the `HbsPosition` should be a one-time operation.
   */


  toHbsPos() {
    let locPos = this._locPos;

    if (locPos === null) {
      let hbsPos = this.source.hbsPosFor(this.charPos);

      if (hbsPos === null) {
        this._locPos = locPos = BROKEN;
      } else {
        this._locPos = locPos = new HbsPosition(this.source, hbsPos, this.charPos);
      }
    }

    return locPos === BROKEN ? null : locPos;
  }

}
export class HbsPosition {
  constructor(source, hbsPos, charPos = null) {
    this.source = source;
    this.hbsPos = hbsPos;
    this.kind = "HbsPosition"
    /* HbsPosition */
    ;
    this._charPos = charPos === null ? null : new CharPosition(source, charPos);
  }
  /**
   * Lazily compute the character offset from the {@see SourcePosition}. Once an `HbsPosition` has
   * computed its `CharPosition`, it will not need to do compute it again, and the same
   * `HbsPosition` is retained when used as one of the ends of a `SourceSpan`, so computing the
   * `CharPosition` should be a one-time operation.
   *
   * @implements {PositionData}
   */


  toCharPos() {
    let charPos = this._charPos;

    if (charPos === null) {
      let charPosNumber = this.source.charPosFor(this.hbsPos);

      if (charPosNumber === null) {
        this._charPos = charPos = BROKEN;
      } else {
        this._charPos = charPos = new CharPosition(this.source, charPosNumber);
      }
    }

    return charPos === BROKEN ? null : charPos;
  }
  /**
   * Return the {@see SourcePosition} that this `HbsPosition` was instantiated with. This operation
   * does not need to compute anything.
   *
   * @implements {PositionData}
   */


  toJSON() {
    return this.hbsPos;
  }

  wrap() {
    return new SourceOffset(this);
  }
  /**
   * This is already an `HbsPosition`.
   *
   * {@see CharPosition} for the alternative.
   */


  toHbsPos() {
    return this;
  }

}
export class InvisiblePosition {
  constructor(kind, // whatever was provided, possibly broken
  pos) {
    this.kind = kind;
    this.pos = pos;
  }
  /**
   * A broken position cannot be turned into a {@see CharacterPosition}.
   */


  toCharPos() {
    return null;
  }
  /**
   * The serialization of an `InvisiblePosition is whatever Handlebars {@see SourcePosition} was
   * originally identified as broken, non-existent or synthetic.
   *
   * If an `InvisiblePosition` never had an source offset at all, this method returns
   * {@see UNKNOWN_POSITION} for compatibility.
   */


  toJSON() {
    return this.pos;
  }

  wrap() {
    return new SourceOffset(this);
  }

  get offset() {
    return null;
  }

}
/**
 * Compare two {@see AnyPosition} and determine whether they are equal.
 *
 * @see {SourceOffset#eql}
 */

const eql = match(m => m.when("HbsPosition"
/* HbsPosition */
, "HbsPosition"
/* HbsPosition */
, ({
  hbsPos: left
}, {
  hbsPos: right
}) => left.column === right.column && left.line === right.line).when("CharPosition"
/* CharPosition */
, "CharPosition"
/* CharPosition */
, ({
  charPos: left
}, {
  charPos: right
}) => left === right).when("CharPosition"
/* CharPosition */
, "HbsPosition"
/* HbsPosition */
, ({
  offset: left
}, right) => {
  var _a;

  return left === ((_a = right.toCharPos()) === null || _a === void 0 ? void 0 : _a.offset);
}).when("HbsPosition"
/* HbsPosition */
, "CharPosition"
/* CharPosition */
, (left, {
  offset: right
}) => {
  var _a;

  return ((_a = left.toCharPos()) === null || _a === void 0 ? void 0 : _a.offset) === right;
}).when(MatchAny, MatchAny, () => false));
//# sourceMappingURL=data:application/json;charset=utf-8;base64,{"version":3,"sources":["../../../../../../packages/@glimmer/syntax/lib/source/loc/offset.ts"],"names":[],"mappings":"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","sourcesContent":["// eslint-disable-next-line import/no-extraneous-dependencies\nimport { SourcePosition, UNKNOWN_POSITION } from '../location';\nimport { Source } from '../source';\nimport { match, MatchAny } from './match';\nimport { SourceSpan, span } from './span';\n\nexport const enum OffsetKind {\n  /**\n   * We have already computed the character position of this offset or span.\n   */\n  CharPosition = 'CharPosition',\n\n  /**\n   * This offset or span was instantiated with a Handlebars SourcePosition or SourceLocation. Its\n   * character position will be computed on demand.\n   */\n  HbsPosition = 'HbsPosition',\n\n  /**\n   * for (rare) situations where a node is created but there was no source location (e.g. the name\n   * \"default\" in default blocks when the word \"default\" never appeared in source). This is used\n   * by the internals when there is a legitimate reason for the internals to synthesize a node\n   * with no location.\n   */\n  InternalsSynthetic = 'InternalsSynthetic',\n  /**\n   * For situations where a node represents zero parts of the source (for example, empty arguments).\n   * In general, we attempt to assign these nodes *some* position (empty arguments can be\n   * positioned immediately after the callee), but it's not always possible\n   */\n  NonExistent = 'NonExistent',\n  /**\n   * For situations where a source location was expected, but it didn't correspond to the node in\n   * the source. This happens if a plugin creates broken locations.\n   */\n  Broken = 'Broken',\n}\n\n/**\n * All positions have these details in common. Most notably, all three kinds of positions can\n * must be able to attempt to convert themselves into {@see CharPosition}.\n */\nexport interface PositionData {\n  readonly kind: OffsetKind;\n  toCharPos(): CharPosition | null;\n  toJSON(): SourcePosition;\n}\n\n/**\n * Used to indicate that an attempt to convert a `SourcePosition` to a character offset failed. It\n * is separate from `null` so that `null` can be used to indicate that the computation wasn't yet\n * attempted (and therefore to cache the failure)\n */\nexport const BROKEN = 'BROKEN';\nexport type BROKEN = 'BROKEN';\n\nexport type AnyPosition = HbsPosition | CharPosition | InvisiblePosition;\n\n/**\n * A `SourceOffset` represents a single position in the source.\n *\n * There are three kinds of backing data for `SourceOffset` objects:\n *\n * - `CharPosition`, which contains a character offset into the raw source string\n * - `HbsPosition`, which contains a `SourcePosition` from the Handlebars AST, which can be\n *   converted to a `CharPosition` on demand.\n * - `InvisiblePosition`, which represents a position not in source (@see {InvisiblePosition})\n */\nexport class SourceOffset {\n  /**\n   * Create a `SourceOffset` from a Handlebars `SourcePosition`. It's stored as-is, and converted\n   * into a character offset on demand, which avoids unnecessarily computing the offset of every\n   * `SourceLocation`, but also means that broken `SourcePosition`s are not always detected.\n   */\n  static forHbsPos(source: Source, pos: SourcePosition): SourceOffset {\n    return new HbsPosition(source, pos, null).wrap();\n  }\n\n  /**\n   * Create a `SourceOffset` that corresponds to a broken `SourcePosition`. This means that the\n   * calling code determined (or knows) that the `SourceLocation` doesn't correspond correctly to\n   * any part of the source.\n   */\n  static broken(pos: SourcePosition = UNKNOWN_POSITION): SourceOffset {\n    return new InvisiblePosition(OffsetKind.Broken, pos).wrap();\n  }\n\n  constructor(readonly data: PositionData & AnyPosition) {}\n\n  /**\n   * Get the character offset for this `SourceOffset`, if possible.\n   */\n  get offset(): number | null {\n    let charPos = this.data.toCharPos();\n    return charPos === null ? null : charPos.offset;\n  }\n\n  /**\n   * Compare this offset with another one.\n   *\n   * If both offsets are `HbsPosition`s, they're equivalent as long as their lines and columns are\n   * the same. This avoids computing offsets unnecessarily.\n   *\n   * Otherwise, two `SourceOffset`s are equivalent if their successfully computed character offsets\n   * are the same.\n   */\n  eql(right: SourceOffset): boolean {\n    return eql(this.data, right.data);\n  }\n\n  /**\n   * Create a span that starts from this source offset and ends with another source offset. Avoid\n   * computing character offsets if both `SourceOffset`s are still lazy.\n   */\n  until(other: SourceOffset): SourceSpan {\n    return span(this.data, other.data);\n  }\n\n  /**\n   * Create a `SourceOffset` by moving the character position represented by this source offset\n   * forward or backward (if `by` is negative), if possible.\n   *\n   * If this `SourceOffset` can't compute a valid character offset, `move` returns a broken offset.\n   *\n   * If the resulting character offset is less than 0 or greater than the size of the source, `move`\n   * returns a broken offset.\n   */\n  move(by: number): SourceOffset {\n    let charPos = this.data.toCharPos();\n\n    if (charPos === null) {\n      return SourceOffset.broken();\n    } else {\n      let result = charPos.offset + by;\n\n      if (charPos.source.check(result)) {\n        return new CharPosition(charPos.source, result).wrap();\n      } else {\n        return SourceOffset.broken();\n      }\n    }\n  }\n\n  /**\n   * Create a new `SourceSpan` that represents a collapsed range at this source offset. Avoid\n   * computing the character offset if it has not already been computed.\n   */\n  collapsed(): SourceSpan {\n    return span(this.data, this.data);\n  }\n\n  /**\n   * Convert this `SourceOffset` into a Handlebars {@see SourcePosition} for compatibility with\n   * existing plugins.\n   */\n  toJSON(): SourcePosition {\n    return this.data.toJSON();\n  }\n}\n\nexport class CharPosition implements PositionData {\n  readonly kind = OffsetKind.CharPosition;\n\n  /** Computed from char offset */\n  _locPos: HbsPosition | BROKEN | null = null;\n\n  constructor(readonly source: Source, readonly charPos: number) {}\n\n  /**\n   * This is already a `CharPosition`.\n   *\n   * {@see HbsPosition} for the alternative.\n   *\n   * @implements {PositionData}\n   */\n  toCharPos(): CharPosition {\n    return this;\n  }\n\n  /**\n   * Produce a Handlebars {@see SourcePosition} for this `CharPosition`. If this `CharPosition` was\n   * computed using {@see SourceOffset#move}, this will compute the `SourcePosition` for the offset.\n   *\n   * @implements {PositionData}\n   */\n  toJSON(): SourcePosition {\n    let hbs = this.toHbsPos();\n    return hbs === null ? UNKNOWN_POSITION : hbs.toJSON();\n  }\n\n  wrap(): SourceOffset {\n    return new SourceOffset(this);\n  }\n\n  /**\n   * A `CharPosition` always has an offset it can produce without any additional computation.\n   */\n  get offset(): number {\n    return this.charPos;\n  }\n\n  /**\n   * Convert the current character offset to an `HbsPosition`, if it was not already computed. Once\n   * a `CharPosition` has computed its `HbsPosition`, it will not need to do compute it again, and\n   * the same `CharPosition` is retained when used as one of the ends of a `SourceSpan`, so\n   * computing the `HbsPosition` should be a one-time operation.\n   */\n  toHbsPos(): HbsPosition | null {\n    let locPos = this._locPos;\n\n    if (locPos === null) {\n      let hbsPos = this.source.hbsPosFor(this.charPos);\n\n      if (hbsPos === null) {\n        this._locPos = locPos = BROKEN;\n      } else {\n        this._locPos = locPos = new HbsPosition(this.source, hbsPos, this.charPos);\n      }\n    }\n\n    return locPos === BROKEN ? null : locPos;\n  }\n}\n\nexport class HbsPosition implements PositionData {\n  readonly kind = OffsetKind.HbsPosition;\n\n  _charPos: CharPosition | BROKEN | null;\n\n  constructor(\n    readonly source: Source,\n    readonly hbsPos: SourcePosition,\n    charPos: number | null = null\n  ) {\n    this._charPos = charPos === null ? null : new CharPosition(source, charPos);\n  }\n\n  /**\n   * Lazily compute the character offset from the {@see SourcePosition}. Once an `HbsPosition` has\n   * computed its `CharPosition`, it will not need to do compute it again, and the same\n   * `HbsPosition` is retained when used as one of the ends of a `SourceSpan`, so computing the\n   * `CharPosition` should be a one-time operation.\n   *\n   * @implements {PositionData}\n   */\n  toCharPos(): CharPosition | null {\n    let charPos = this._charPos;\n\n    if (charPos === null) {\n      let charPosNumber = this.source.charPosFor(this.hbsPos);\n\n      if (charPosNumber === null) {\n        this._charPos = charPos = BROKEN;\n      } else {\n        this._charPos = charPos = new CharPosition(this.source, charPosNumber);\n      }\n    }\n\n    return charPos === BROKEN ? null : charPos;\n  }\n\n  /**\n   * Return the {@see SourcePosition} that this `HbsPosition` was instantiated with. This operation\n   * does not need to compute anything.\n   *\n   * @implements {PositionData}\n   */\n  toJSON(): SourcePosition {\n    return this.hbsPos;\n  }\n\n  wrap(): SourceOffset {\n    return new SourceOffset(this);\n  }\n\n  /**\n   * This is already an `HbsPosition`.\n   *\n   * {@see CharPosition} for the alternative.\n   */\n  toHbsPos(): HbsPosition {\n    return this;\n  }\n}\n\nexport class InvisiblePosition implements PositionData {\n  constructor(\n    readonly kind: OffsetKind.Broken | OffsetKind.InternalsSynthetic | OffsetKind.NonExistent,\n    // whatever was provided, possibly broken\n    readonly pos: SourcePosition\n  ) {}\n\n  /**\n   * A broken position cannot be turned into a {@see CharacterPosition}.\n   */\n  toCharPos(): null {\n    return null;\n  }\n\n  /**\n   * The serialization of an `InvisiblePosition is whatever Handlebars {@see SourcePosition} was\n   * originally identified as broken, non-existent or synthetic.\n   *\n   * If an `InvisiblePosition` never had an source offset at all, this method returns\n   * {@see UNKNOWN_POSITION} for compatibility.\n   */\n  toJSON(): SourcePosition {\n    return this.pos;\n  }\n\n  wrap(): SourceOffset {\n    return new SourceOffset(this);\n  }\n\n  get offset(): null {\n    return null;\n  }\n}\n\n/**\n * Compare two {@see AnyPosition} and determine whether they are equal.\n *\n * @see {SourceOffset#eql}\n */\nconst eql = match<boolean>((m) =>\n  m\n    .when(\n      OffsetKind.HbsPosition,\n      OffsetKind.HbsPosition,\n      ({ hbsPos: left }, { hbsPos: right }) =>\n        left.column === right.column && left.line === right.line\n    )\n    .when(\n      OffsetKind.CharPosition,\n      OffsetKind.CharPosition,\n      ({ charPos: left }, { charPos: right }) => left === right\n    )\n    .when(\n      OffsetKind.CharPosition,\n      OffsetKind.HbsPosition,\n      ({ offset: left }, right) => left === right.toCharPos()?.offset\n    )\n    .when(\n      OffsetKind.HbsPosition,\n      OffsetKind.CharPosition,\n      (left, { offset: right }) => left.toCharPos()?.offset === right\n    )\n    .when(MatchAny, MatchAny, () => false)\n);\n"],"sourceRoot":""}