@speleotica/frcsdata 4.3.1 → 5.0.0-beta.2

package/survey/parseFrcsSurveyFile.js

@@ -0,0 +1,626 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = parseFrcsSurveyFile;
+var _FrcsSurveyFile = require("./FrcsSurveyFile.js");
+var _unitized = require("@speleotica/unitized");
+var _chunksToLines = require("../chunksToLines.js");
+var _validators = require("./validators.js");
+var _getColumnRanges = require("./getColumnRanges.js");
+var _parsers = require("./parsers.js");
+var _normalizeTeamMemberName = require("./normalizeTeamMemberName.js");
+var _unwrapInvalid = require("../unwrapInvalid.js");
+/**
+   * Parses a raw cdata.fr survey file.  These look like so:
+   *
+  <pre>      Fisher Ridge Cave System, Hart Co., KY
+  ENTRANCE DROPS, JOE'S "I LOVE MY WIFE TRAVERSE", TRICKY TRAVERSE
+  PETER QUICK, KEITH ORTIZ   -  2-15-81
+  This File has Crumps test connected.  11/20/12
+  *
+  FT C  DD    A
+        AE20     0                          1  3  0  2
+  *      %FS
+  *     AE20     0        0        0        Bug-can't put before so put after-so can't make 2 fixed 10/28/12
+  AE19 AE20   9.3    60.0  60.0-36.0       2 12  0 20
+  AE18 AE19  24.5     0.0   0.0-90.0       6 10 25  0
+  AE17 AE18   8.0   350.5 350.5 17.0       3  5  0  0
+  AE16 AE17   6.7     0.0   0.0-90.0       3  5  6  1
+  AE15 AE16  12.6    70.5  71.0-18.0       4  0  2  1
+  AE14 AE15  10.0    21.5  20.0  6.0       5  5  0  3
+  AE13 AE14  26.8   288.0 286.0-50.0       0  7 20  5
+  *
+  *SHORT CANYON AT THE BASE OF THE SECOND DROP
+  AE12 AE13  20.7   236.0 236.0 34.0       3  5  4  4
+  AE11 AE12  12.4   210.0 210.0 35.0       7  4  5  1
+  AE10 AE13  25.7    40.0  40.0 -9.0       2  2  3  6
+  *
+  *AE10 AT JOE'S " I LOVE MY WIFE TRAVERSE "
+    AE9 AE10  17.8    32.5  31.0 23.0       4  5 20 15
+    AE1  AE9  13.7    82.0  82.0-13.0
+    A1  AE1  34.3    46.0  48.0-17.5
+  *
+  *SURVEY TO DOME NEAR THE ENTRANCE DOME (ABOVE THE SECOND DROP)
+    AD1 AE15   8.0   200.0 200.0  0.0       3  1  1  1
+    AD2  AD1  17.7   161.0 161.0  7.0       1  4 25  1
+    AD3  AD2  10.4   180.0 180.0 50.0       4  1 15  5
+  *
+  TRICKY TRAVERSE AND THEN FIRST SURVEY IN UPPER CROWLWAY
+  DAN CROWL, KEITH ORTIZ, CHIP HOPPER, PETER QUICK, LARRY BEAN    14 FEB 1981
+  *
+  FI B  DD
+    A2   A1  48 10  292.0 110.0-42.0       5 10 35  5
+    A3   A2  12  5  333.5 153.5 35.0       3  1 15  5
+    A4   A3   4  2    0.0   0.0 90.0       3  1 10 10
+  ...</pre>
+  *
+  */
+async function parseFrcsSurveyFile(file,
+// eslint-disable-line @typescript-eslint/no-explicit-any
+chunks, {
+  columns = _FrcsSurveyFile.defaultFrcsShotColumnConfig,
+  outputColumns = false,
+  normalizeNames = true,
+  suppressWarnings
+} = {}) {
+  const columnRanges = (0, _getColumnRanges.getColumnRanges)(columns);
+  const maxRange = Math.max(...Object.values(columnRanges.decimal).map(r => r[1]));
+  let cave = undefined;
+  let location = undefined;
+  const trips = [];
+  const issues = [];
+  let tripName;
+  let tripTeam;
+  let tripDate;
+  let inTripComment = true;
+  let tripCommentStartLine = 1;
+  let tripCommentEndLine = -1;
+  const tripComment = [];
+  const commentLines = [];
+  let trip = undefined;
+  let inBlockComment = false;
+  let section;
+  const commentFromStationLruds = new Map();
+  let unitsChanged = false;
+  let alternateUnits;
+  let nextShotUnits;
+  let lineNumber = 0;
+  let line;
+  let lineStartIndex = 0;
+  let lineIssues = [];
+  let tripIssues = [];
+  let began = false;
+  for await ({
+    line,
+    startIndex: lineStartIndex
+  } of (0, _chunksToLines.chunksToLines)(chunks)) {
+    if (lineIssues.length) lineIssues = [];
+    lineNumber++;
+    if (!began) {
+      began = true;
+      if (/^\s+\*/.test(line)) {
+        continue;
+      }
+      const match = /^\s*([^,]+)(,(.*))?/.exec(line);
+      if (match) {
+        cave = match[1].trim();
+        if (match[3]) {
+          location = match[3].trim();
+        }
+      }
+    }
+    if (unitsChanged) {
+      unitsChanged = false;
+      alternateUnits = parseUnits();
+      nextShotUnits = alternateUnits;
+    } else if (/^\s{1,8}\*(?!\*)/.test(line)) {
+      inTripComment = !inTripComment;
+      alternateUnits = nextShotUnits = undefined;
+      unitsChanged = false;
+      if (inTripComment) {
+        section = undefined;
+        tripTeam = undefined;
+        tripDate = undefined;
+        tripComment.length = 0;
+        tripCommentStartLine = lineNumber;
+      } else {
+        tripCommentEndLine = lineNumber;
+      }
+    } else if (inTripComment) {
+      if (lineNumber === tripCommentStartLine + 1) {
+        tripName = line && line.trim();
+      } else if (lineNumber === tripCommentStartLine + 2) {
+        const dateMatch = /(?:[-.]\s*)?((\d+)[-/](\d+)[-/](\d{2,4})|((\d+)[-/ ](january|february|march|april|may|june|july|august|september|october|november|december|(?:jan|feb|mar|apr|jun|jul|aug|sept?|oct|nov|dec)\.?)[-/ ](\d{2,4}))|((january|february|march|april|may|june|july|august|september|october|november|december|(?:jan|feb|mar|apr|jun|jul|aug|sept?|oct|nov|dec)\.?)\s+(\d+)(?:,\s*|,?\s+)(\d{2,4})))/i.exec(line);
+        if (dateMatch) {
+          const team = line.substring(0, dateMatch.index);
+          tripTeam = team.split(team.indexOf(';') >= 0 ? ';' : ',').flatMap(member => member.trim() || []);
+          if (!tripTeam.length) {
+            addIssue('warning', 'missingTripTeam', 'Missing team', 0, dateMatch.index, tripIssues);
+          }
+          if (normalizeNames) tripTeam = tripTeam.map(_normalizeTeamMemberName.normalizeTeamMemberName);
+          let month, day, year;
+          if (dateMatch[2]) {
+            month = parseInt(dateMatch[2]);
+            day = parseInt(dateMatch[3]);
+            year = parseInt(dateMatch[4]);
+          } else if (dateMatch[6]) {
+            day = parseInt(dateMatch[6]);
+            month = (0, _parsers.parseMonth)(dateMatch[7]);
+            year = parseInt(dateMatch[8]);
+          } else {
+            month = (0, _parsers.parseMonth)(dateMatch[10]);
+            day = parseInt(dateMatch[11]);
+            year = parseInt(dateMatch[12]);
+          }
+          tripDate = new Date(year < 60 ? year + 2000 : year, month - 1, day);
+        } else {
+          addIssue('warning', 'missingTripDate', 'Missing date', line.length, line.length, tripIssues);
+        }
+      } else if (lineNumber > 1) {
+        tripComment.push(line);
+      }
+      const match = /^\*\*\*([^*]+)\*\*\*/.exec(line);
+      if (match) {
+        section = match[1].trim();
+      }
+    } else if (/^(\s{9,}|)\*(?!\*)/.test(line)) {
+      if (/^\*\s*%NC(\b|$)/.test(line)) {
+        unitsChanged = true;
+      }
+      if (/^\*\s*%/.test(line)) {
+        continue;
+      }
+      if (/[^\s*]/.test(line)) {
+        addCommentLine(line.replace(/^\s*\*/, ''));
+        inBlockComment = false;
+      } else {
+        inBlockComment = !inBlockComment;
+        if (inBlockComment) commentLines.length = 0;
+      }
+    } else if (inBlockComment) {
+      addCommentLine(line);
+    } else if (lineNumber === tripCommentEndLine + 1) {
+      if (trip) trips.push(trip);
+      const header = {
+        name: tripName || '',
+        comment: tripComment && tripComment.join('\n') || undefined,
+        section,
+        date: tripDate,
+        team: tripTeam
+      };
+      const units = parseUnits();
+      if ('INVALID' in units || tripIssues.some(i => issues[i]?.type === 'error')) {
+        trip = {
+          INVALID: {
+            header,
+            units,
+            shots: []
+          },
+          ...(tripIssues.length ? {
+            issues: tripIssues
+          } : {})
+        };
+      } else {
+        trip = {
+          tripNumber: 1,
+          header,
+          units,
+          shots: []
+        };
+      }
+      tripIssues = [];
+    } else if (trip) {
+      let distanceUnit = (0, _unwrapInvalid.unwrapInvalid)(alternateUnits)?.distanceUnit || (0, _unwrapInvalid.unwrapInvalid)((0, _unwrapInvalid.unwrapInvalid)(trip).units).distanceUnit || _unitized.Length.feet;
+      const azimuthUnit = (0, _unwrapInvalid.unwrapInvalid)(alternateUnits)?.azimuthUnit || (0, _unwrapInvalid.unwrapInvalid)((0, _unwrapInvalid.unwrapInvalid)(trip).units).azimuthUnit || _unitized.Angle.degrees;
+      const inclinationUnit = (0, _unwrapInvalid.unwrapInvalid)(alternateUnits)?.inclinationUnit || (0, _unwrapInvalid.unwrapInvalid)((0, _unwrapInvalid.unwrapInvalid)(trip).units).inclinationUnit || _unitized.Angle.degrees;
+      const inches = distanceUnit === _unitized.Length.inches;
+      if (inches) distanceUnit = _unitized.Length.feet;
+      const ranges = inches ? columnRanges.feetAndInches : columnRanges.decimal;
+
+      // from station name
+      if (!/\S/.test(line.substring(...ranges.fromStation))) continue;
+      const fromStr = validate(...ranges.fromStation, 'from station', _validators.isValidStation);
+      const from = fromStr.trim();
+
+      // Sadly I have found negative LRUD values in Chip's format and apparently
+      // his program doesn't fail on them, so I have to accept them here
+      // isValidOptFloat instead of isValidOptUFloat
+      const lStr = validate(...ranges.left, 'left', _validators.isValidOptFloat);
+      const rStr = validate(...ranges.right, 'right', _validators.isValidOptFloat);
+      const uStr = validate(...ranges.up, 'up', _validators.isValidOptFloat);
+      const dStr = validate(...ranges.down, 'down', _validators.isValidOptFloat);
+      const up = (0, _parsers.parseLrud)(uStr, distanceUnit);
+      const down = (0, _parsers.parseLrud)(dStr, distanceUnit);
+      const left = (0, _parsers.parseLrud)(lStr, distanceUnit);
+      const right = (0, _parsers.parseLrud)(rStr, distanceUnit);
+
+      // to station name
+      const toStr = line.substring(...ranges.toStation);
+      if (!toStr.trim()) {
+        const shot = {
+          from,
+          to: undefined,
+          distance: new _unitized.UnitizedNumber(0, distanceUnit),
+          frontsightAzimuth: undefined,
+          backsightAzimuth: undefined,
+          frontsightInclination: undefined,
+          backsightInclination: undefined,
+          fromLruds: {
+            left,
+            right,
+            up,
+            down
+          },
+          excludeDistance: true,
+          comment: getComment()
+        };
+        addShot(lineIssues.length ? {
+          INVALID: shot,
+          issues: lineIssues
+        } : shot);
+        continue;
+      }
+      if (!(0, _validators.isValidStation)(toStr)) {
+        addIssue('error', 'invalidStationName', 'Invalid station name', ...ranges.toStation);
+      }
+      let fromLruds = commentFromStationLruds.get(from);
+      if (fromLruds) {
+        commentFromStationLruds.delete(from);
+      } else {
+        const fromLrudMatch = new RegExp(`^\\s+${fromStr.trim().replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}((\\s+(\\d+(\\.\\d*)?|\\.\\d+)){4})`).exec(line.substring(maxRange));
+        if (fromLrudMatch) {
+          const [left, right, up, down] = fromLrudMatch[1].trim().split(/\s+/g).map(s => (0, _parsers.parseLrud)(s, distanceUnit));
+          fromLruds = {
+            left,
+            right,
+            up,
+            down
+          };
+        }
+      }
+      const comment = getComment();
+
+      // azimuth and inclination
+      const azmFsStr = validate(ranges.frontsightAzimuth[0], ranges.frontsightAzimuth[1], 'azimuth', _validators.isValidOptUFloat);
+      const azmBsStr = validate(...ranges.backsightAzimuth, 'azimuth', _validators.isValidOptUFloat);
+      const incFsStr = line.substring(...ranges.frontsightInclination);
+      const incBsStr = line.substring(...ranges.backsightInclination);
+      let distance;
+      let horizontalDistance;
+      let verticalDistance;
+      let frontsightInclination;
+      let backsightInclination;
+
+      // parse distance
+      if (inches) {
+        const feetStr = validate(...ranges.distanceFeet, 'feet', _validators.isValidOptUFloat);
+        const inchesStr = validate(...ranges.distanceInches, 'inches', _validators.isValidOptUFloat);
+        if (!/\S/.test(feetStr) && !/\S/.test(inchesStr)) {
+          addIssue('error', 'missingDistance', 'Missing distance', ranges.distanceFeet[0], ranges.distanceInches[1]);
+        }
+        // sometimes inches are omitted, hence the || 0...I'm assuming it's possible
+        // for feet to be omitted as well
+        else if ((0, _validators.isValidUInt)(feetStr) && (0, _validators.isValidOptUFloat)(inchesStr) || (0, _validators.isValidOptUFloat)(feetStr) && (0, _validators.isValidUInt)(inchesStr)) {
+          distance = _unitized.Unitize.inches(parseFloat(inchesStr) || 0).add(_unitized.Unitize.feet(parseFloat(feetStr) || 0));
+        }
+        // NOTE there are two columns around here that can contain a *.
+        // I think they might represent different values, but thisis confused by
+        // the fact that for ft/in shots, if there is a D or H flag it occupies the
+        // first column that can contain a * for decimal feet shots
+      } else {
+        const distStr = validate(...ranges.distance, 'distance', _validators.isValidUFloat);
+        const distNum = parseFloat(distStr);
+        distance = Number.isFinite(distNum) ? new _unitized.UnitizedNumber(distNum, distanceUnit) : undefined;
+      }
+      const specialKindStr = line.substring(...ranges.kind).trim();
+      const exclude = line.substring(...ranges.exclude).trim();
+      const specialKind = (0, _parsers.parseSpecialKind)(specialKindStr);
+      if (specialKindStr && !specialKind) {
+        addIssue('error', 'invalidShotType', 'Invalid shot type', ranges.kind[0], ranges.kind[1]);
+      }
+      const excludeDistance = exclude === '*' || exclude === 's';
+      const isSplay = exclude === 's';
+      if (exclude && !excludeDistance) {
+        addIssue('error', 'invalidShotFlag', 'Invalid shot flag', ranges.exclude[0], ranges.exclude[1]);
+      }
+      if (specialKind) {
+        validate(...ranges.frontsightInclination, 'vertical-distance', _validators.isValidFloat);
+      }
+
+      // convert horizontal and diagonal shots to standard
+      // in this case incFs is the vertical offset between stations
+      // fortunately it appears we can always count on incFs being specified
+      // and incBs not being specified for these types of shots
+      if (specialKind === 'horizontal') {
+        // distance is horizontal offset and incFsStr is vertical offset
+        horizontalDistance = distance;
+        const h = horizontalDistance?.get(distanceUnit) ?? NaN;
+        const v = parseFloat(incFsStr);
+        verticalDistance = Number.isFinite(v) ? new _unitized.UnitizedNumber(v, distanceUnit) : undefined;
+        distance = new _unitized.UnitizedNumber(Math.sqrt(h * h + v * v), distanceUnit);
+        frontsightInclination = verticalDistance && horizontalDistance ? _unitized.Angle.atan2(verticalDistance, horizontalDistance).in(inclinationUnit) : undefined;
+        backsightInclination = undefined;
+      } else if (specialKind === 'diagonal') {
+        // distance is as usual, but incFsStr is vertical offset
+        const d = distance?.get(distanceUnit) ?? NaN;
+        const v = parseFloat(incFsStr);
+        verticalDistance = Number.isFinite(v) ? new _unitized.UnitizedNumber(v, distanceUnit) : undefined;
+        frontsightInclination = _unitized.Angle.asin(v / d).in(inclinationUnit);
+        backsightInclination = undefined;
+      } else {
+        // frontsight inclination
+        validate(...ranges.frontsightInclination, 'inclination', _validators.isValidOptFloat);
+        // backsight inclination
+        validate(...ranges.backsightInclination, 'inclination', _validators.isValidOptFloat);
+        frontsightInclination = (0, _parsers.parseNumber)(incFsStr, inclinationUnit);
+        backsightInclination = (0, _parsers.parseNumber)(incBsStr, inclinationUnit);
+      }
+      const frontsightAzimuth = (0, _parsers.parseAzimuth)(azmFsStr, azimuthUnit);
+      const backsightAzimuth = (0, _parsers.parseAzimuth)(azmBsStr, azimuthUnit);
+      if (!/\S/.test(incFsStr) && !/\S/.test(incBsStr)) {
+        frontsightInclination = _unitized.Unitize.degrees(0);
+      }
+      if (from && distance && !lineIssues.length) {
+        const shot = {
+          from,
+          to: toStr.trim(),
+          specialKind,
+          distance,
+          frontsightAzimuth,
+          backsightAzimuth,
+          frontsightInclination,
+          backsightInclination,
+          toLruds: {
+            left,
+            right,
+            up,
+            down
+          },
+          excludeDistance,
+          comment
+        };
+        if (isSplay) shot.isSplay = true;
+        if (fromLruds) shot.fromLruds = fromLruds;
+        if (horizontalDistance) shot.horizontalDistance = horizontalDistance;
+        if (verticalDistance) shot.verticalDistance = verticalDistance;
+        addShot(shot);
+      } else {
+        const shot = {
+          from,
+          to: toStr.trim(),
+          specialKind,
+          distance,
+          frontsightAzimuth,
+          backsightAzimuth,
+          frontsightInclination,
+          backsightInclination,
+          toLruds: {
+            left,
+            right,
+            up,
+            down
+          },
+          excludeDistance,
+          comment
+        };
+        if (isSplay) shot.isSplay = true;
+        if (fromLruds) shot.fromLruds = fromLruds;
+        if (horizontalDistance) shot.horizontalDistance = horizontalDistance;
+        if (verticalDistance) shot.verticalDistance = verticalDistance;
+        addShot({
+          INVALID: shot,
+          issues: lineIssues
+        });
+      }
+    }
+  }
+  if (trip) trips.push(trip);
+  trips.forEach((trip, index) => (0, _unwrapInvalid.unwrapInvalid)(trip).tripNumber = index + 1);
+  if (!issues.some(i => i.type === 'error') && trips.every(t => !('INVALID' in t))) {
+    return {
+      cave,
+      columns: outputColumns ? columns : undefined,
+      location,
+      trips,
+      ...(issues.length ? {
+        issues
+      } : undefined)
+    };
+  }
+  return {
+    INVALID: {
+      cave,
+      columns: outputColumns ? columns : undefined,
+      location,
+      trips
+    },
+    issues
+  };
+
+  ////////////////////////////////////////////////////////////////////////////////////////////
+
+  function getComment() {
+    if (!commentLines?.length) return undefined;
+    const comment = commentLines.join('\n').trim();
+    commentLines.length = 0;
+    return comment || undefined;
+  }
+  function addCommentLine(comment) {
+    if (trip) {
+      const distanceUnit = (0, _unwrapInvalid.unwrapInvalid)(alternateUnits)?.distanceUnit || (0, _unwrapInvalid.unwrapInvalid)((0, _unwrapInvalid.unwrapInvalid)(trip).units).distanceUnit || _unitized.Length.feet;
+      const parsedFromStationLruds = (0, _parsers.parseFromStationLruds)(comment, distanceUnit);
+      if (parsedFromStationLruds) {
+        commentFromStationLruds.set(parsedFromStationLruds[0], parsedFromStationLruds[1]);
+        return;
+      }
+    }
+    if (commentLines) {
+      commentLines.push(comment);
+    }
+  }
+  function addIssue(type, code, message, startColumn, endColumn, indicesArray) {
+    if (suppressWarnings && type === 'warning' && (suppressWarnings === true || 'code' in suppressWarnings && suppressWarnings[code] === true)) {
+      return;
+    }
+    issues.push({
+      type,
+      code,
+      message,
+      loc: {
+        start: {
+          line: lineNumber,
+          column: startColumn,
+          index: lineStartIndex + startColumn
+        },
+        end: {
+          line: lineNumber,
+          column: endColumn,
+          index: lineStartIndex + endColumn
+        }
+      }
+    });
+    if (!lineIssues) lineIssues = [];
+    lineIssues.push(issues.length - 1);
+    indicesArray?.push(issues.length - 1);
+  }
+  function parseUnits() {
+    // FT CC DD
+    // 01234567
+    const distanceUnit = (0, _parsers.parseLengthUnit)(line.slice(0, 2));
+    if (!distanceUnit) {
+      addIssue('error', 'invalidDistanceUnit', 'Invalid distance unit', 0, 2);
+    }
+    const azimuthUnit = (0, _parsers.parseAngleUnit)(line[6]);
+    if (!azimuthUnit) {
+      addIssue('error', 'invalidAzimuthUnit', 'Invalid azimuth unit', 6, 7);
+    }
+    const inclinationUnit = (0, _parsers.parseAngleUnit)(line[7]);
+    if (!inclinationUnit) {
+      addIssue('error', 'invalidInclinationUnit', 'Invalid inclination unit', 7, 8);
+    }
+    const backsightAzimuthCorrected = line[3] === 'C';
+    const backsightInclinationCorrected = line[4] === 'C';
+    const hasBacksightAzimuth = line[3] !== ' ' && line[3] !== '-';
+    const hasBacksightInclination = line[4] !== ' ' && line[4] !== '-';
+    if (!/[-CB ]/.test(line[3])) {
+      addIssue('error', 'invalidBacksightAzimuthType', 'Invalid backsight azimuth type', 3, 4);
+    }
+    if (!/[-CB ]/.test(line[4])) {
+      addIssue('error', 'invalidBacksightInclinationType', 'Invalid backsight inclination type', 4, 5);
+    }
+    if (!distanceUnit || !azimuthUnit || !inclinationUnit) {
+      return {
+        INVALID: {
+          distanceUnit,
+          azimuthUnit,
+          inclinationUnit,
+          backsightAzimuthCorrected,
+          backsightInclinationCorrected,
+          hasBacksightAzimuth,
+          hasBacksightInclination
+        },
+        issues: lineIssues
+      };
+    }
+    return {
+      distanceUnit,
+      azimuthUnit,
+      inclinationUnit,
+      backsightAzimuthCorrected,
+      backsightInclinationCorrected,
+      hasBacksightAzimuth,
+      hasBacksightInclination
+    };
+  }
+  function validate(startColumn, endColumn, fieldName, validator) {
+    const field = line.substring(startColumn, endColumn);
+    if (!validator(field)) {
+      addIssue('error', `${field.trim() ? 'invalid' : 'missing'}${fieldName[0].toUpperCase()}${fieldName.substring(1)}`, (field.trim() ? 'Invalid ' : 'Missing ') + fieldName, startColumn, endColumn);
+    }
+    return field;
+  }
+  function addShot(shot) {
+    if (!trip) return;
+    if (alternateUnits) {
+      const recorded = shot;
+      if ('INVALID' in shot) {
+        shot.INVALID = {
+          ...shot.INVALID,
+          recorded
+        };
+      } else if ('INVALID' in recorded) {
+        shot = {
+          INVALID: {
+            ...shot,
+            recorded
+          }
+        };
+      } else {
+        shot = {
+          ...shot,
+          recorded
+        };
+      }
+      if (nextShotUnits) {
+        (0, _unwrapInvalid.unwrapInvalid)(recorded).units = nextShotUnits;
+        nextShotUnits = undefined;
+      }
+      const {
+        backsightAzimuthCorrected,
+        backsightInclinationCorrected,
+        distanceUnit,
+        azimuthUnit,
+        inclinationUnit
+      } = (0, _unwrapInvalid.unwrapInvalid)((0, _unwrapInvalid.unwrapInvalid)(trip).units);
+      const unwrappedAlternateUnits = (0, _unwrapInvalid.unwrapInvalid)(alternateUnits);
+      const unwrappedShot = (0, _unwrapInvalid.unwrapInvalid)(shot);
+      {
+        const alternateUnits = unwrappedAlternateUnits;
+        const shot = unwrappedShot;
+        if (alternateUnits.backsightAzimuthCorrected !== backsightAzimuthCorrected) {
+          shot.backsightAzimuth = shot.backsightAzimuth ? _unitized.Angle.opposite(shot.backsightAzimuth) : undefined;
+        }
+        if (alternateUnits.backsightInclinationCorrected !== backsightInclinationCorrected) {
+          shot.backsightInclination = shot.backsightInclination?.negate();
+        }
+        if (distanceUnit && distanceUnit !== alternateUnits.distanceUnit) {
+          shot.distance = shot.distance?.in(distanceUnit);
+          if (shot.fromLruds) {
+            shot.fromLruds.left = shot.fromLruds.left?.in(distanceUnit);
+            shot.fromLruds.right = shot.fromLruds.right?.in(distanceUnit);
+            shot.fromLruds.up = shot.fromLruds.up?.in(distanceUnit);
+            shot.fromLruds.down = shot.fromLruds.down?.in(distanceUnit);
+          }
+          if (shot.toLruds) {
+            shot.toLruds.left = shot.toLruds.left?.in(distanceUnit);
+            shot.toLruds.right = shot.toLruds.right?.in(distanceUnit);
+            shot.toLruds.up = shot.toLruds.up?.in(distanceUnit);
+            shot.toLruds.down = shot.toLruds.down?.in(distanceUnit);
+          }
+        }
+        if (azimuthUnit && azimuthUnit !== alternateUnits.azimuthUnit) {
+          shot.frontsightAzimuth = shot.frontsightAzimuth?.in(azimuthUnit);
+          shot.backsightAzimuth = shot.backsightAzimuth?.in(azimuthUnit);
+        }
+        if (inclinationUnit && inclinationUnit !== alternateUnits.inclinationUnit) {
+          shot.frontsightInclination = shot.frontsightInclination?.in(inclinationUnit);
+          shot.backsightInclination = shot.backsightInclination?.in(inclinationUnit);
+        }
+      }
+    }
+    if ('INVALID' in trip) {
+      trip.INVALID.shots.push(shot);
+    } else if ('INVALID' in shot) {
+      trip = {
+        INVALID: trip
+      };
+      trip.INVALID.shots.push(shot);
+    } else {
+      trip.shots.push(shot);
+    }
+  }
+}
+module.exports = exports.default;
+//# sourceMappingURL=parseFrcsSurveyFile.js.map