svg-path-commander 2.1.2 → 2.1.5

package/src/parser/scanFlag.ts

@@ -1,29 +0,0 @@
-import error from './error';
-import type PathParser from './pathParser';
-
-/**
- * Validates an A (arc-to) specific path command value.
- * Usually a `large-arc-flag` or `sweep-flag`.
- *
- * @param path the `PathParser` instance
- */
-const scanFlag = (path: PathParser) => {
-  const { index, pathValue } = path;
-  const code = pathValue.charCodeAt(index);
-
-  if (code === 0x30 /* 0 */) {
-    path.param = 0;
-    path.index += 1;
-    return;
-  }
-
-  if (code === 0x31 /* 1 */) {
-    path.param = 1;
-    path.index += 1;
-    return;
-  }
-
-  path.err = `${error}: invalid Arc flag "${pathValue[index]}", expecting 0 or 1 at index ${index}`;
-};
-
-export default scanFlag;

package/src/parser/scanParam.ts

@@ -1,102 +0,0 @@
-import isDigit from './isDigit';
-import invalidPathValue from './invalidPathValue';
-import error from './error';
-import type PathParser from './pathParser';
-
-/**
- * Validates every character of the path string,
- * every path command, negative numbers or floating point numbers.
- *
- * @param path the `PathParser` instance
- */
-const scanParam = (path: PathParser) => {
-  const { max, pathValue, index: start } = path;
-  let index = start;
-  let zeroFirst = false;
-  let hasCeiling = false;
-  let hasDecimal = false;
-  let hasDot = false;
-  let ch;
-
-  if (index >= max) {
-    path.err = `${error}: ${invalidPathValue} at index ${index}, "pathValue" is missing param`;
-    return;
-  }
-  ch = pathValue.charCodeAt(index);
-
-  if (ch === 0x2b /* + */ || ch === 0x2d /* - */) {
-    index += 1;
-    // ch = (index < max) ? pathValue.charCodeAt(index) : 0;
-    ch = pathValue.charCodeAt(index);
-  }
-
-  // This logic is shamelessly borrowed from Esprima
-  // https://github.com/ariya/esprimas
-  if (!isDigit(ch) && ch !== 0x2e /* . */) {
-    // path.err = 'SvgPath: param should start with 0..9 or `.` (at pos ' + index + ')';
-    path.err = `${error}: ${invalidPathValue} at index ${index}, "${pathValue[index]}" is not a number`;
-    return;
-  }
-
-  if (ch !== 0x2e /* . */) {
-    zeroFirst = ch === 0x30 /* 0 */;
-    index += 1;
-
-    ch = pathValue.charCodeAt(index);
-
-    if (zeroFirst && index < max) {
-      // decimal number starts with '0' such as '09' is illegal.
-      if (ch && isDigit(ch)) {
-        // path.err = 'SvgPath: numbers started with `0` such as `09`
-        // are illegal (at pos ' + start + ')';
-        path.err = `${error}: ${invalidPathValue} at index ${start}, "${pathValue[start]}" illegal number`;
-        return;
-      }
-    }
-
-    while (index < max && isDigit(pathValue.charCodeAt(index))) {
-      index += 1;
-      hasCeiling = true;
-    }
-
-    ch = pathValue.charCodeAt(index);
-  }
-
-  if (ch === 0x2e /* . */) {
-    hasDot = true;
-    index += 1;
-    while (isDigit(pathValue.charCodeAt(index))) {
-      index += 1;
-      hasDecimal = true;
-    }
-
-    ch = pathValue.charCodeAt(index);
-  }
-
-  if (ch === 0x65 /* e */ || ch === 0x45 /* E */) {
-    if (hasDot && !hasCeiling && !hasDecimal) {
-      path.err = `${error}: ${invalidPathValue} at index ${index}, "${pathValue[index]}" invalid float exponent`;
-      return;
-    }
-
-    index += 1;
-
-    ch = pathValue.charCodeAt(index);
-
-    if (ch === 0x2b /* + */ || ch === 0x2d /* - */) {
-      index += 1;
-    }
-    if (index < max && isDigit(pathValue.charCodeAt(index))) {
-      while (index < max && isDigit(pathValue.charCodeAt(index))) {
-        index += 1;
-      }
-    } else {
-      path.err = `${error}: ${invalidPathValue} at index ${index}, "${pathValue[index]}" invalid integer exponent`;
-      return;
-    }
-  }
-
-  path.index = index;
-  path.param = +path.pathValue.slice(start, index);
-};
-export default scanParam;

package/src/parser/scanSegment.ts

@@ -1,84 +0,0 @@
-import finalizeSegment from './finalizeSegment';
-import paramCounts from './paramsCount';
-import scanFlag from './scanFlag';
-import scanParam from './scanParam';
-import skipSpaces from './skipSpaces';
-import isPathCommand from './isPathCommand';
-import isDigitStart from './isDigitStart';
-import isArcCommand from './isArcCommand';
-import isMoveCommand from './isMoveCommand';
-import invalidPathValue from './invalidPathValue';
-import error from './error';
-
-import type PathParser from './pathParser';
-import type { PathSegment, RelativeCommand } from '../types';
-
-/**
- * Scans every character in the path string to determine
- * where a segment starts and where it ends.
- *
- * @param path the `PathParser` instance
- */
-const scanSegment = (path: PathParser) => {
-  const { max, pathValue, index, segments } = path;
-  const cmdCode = pathValue.charCodeAt(index);
-  const reqParams = paramCounts[pathValue[index].toLowerCase() as RelativeCommand];
-
-  path.segmentStart = index;
-
-  // segments always start with a path command
-  if (!isPathCommand(cmdCode)) {
-    path.err = `${error}: ${invalidPathValue} "${pathValue[index]}" is not a path command at index ${index}`;
-    return;
-  }
-
-  // after a Z segment, we only expect a MoveTo path command
-  const lastSegment = segments[segments.length - 1] as PathSegment | undefined;
-  if (!isMoveCommand(cmdCode) && lastSegment?.[0]?.toLocaleLowerCase() === 'z') {
-    path.err = `${error}: ${invalidPathValue} "${pathValue[index]}" is not a MoveTo path command at index ${index}`;
-    return;
-  }
-
-  path.index += 1;
-  skipSpaces(path);
-
-  path.data = [];
-
-  if (!reqParams) {
-    // Z
-    finalizeSegment(path);
-    return;
-  }
-
-  for (;;) {
-    for (let i = reqParams; i > 0; i -= 1) {
-      if (isArcCommand(cmdCode) && (i === 3 || i === 4)) scanFlag(path);
-      else scanParam(path);
-
-      if (path.err.length) {
-        return;
-      }
-      path.data.push(path.param);
-
-      skipSpaces(path);
-
-      // after ',' param is mandatory
-      if (path.index < max && pathValue.charCodeAt(path.index) === 0x2c /* , */) {
-        path.index += 1;
-        skipSpaces(path);
-      }
-    }
-
-    if (path.index >= path.max) {
-      break;
-    }
-
-    // Stop on next segment
-    if (!isDigitStart(pathValue.charCodeAt(path.index))) {
-      break;
-    }
-  }
-
-  finalizeSegment(path);
-};
-export default scanSegment;

package/src/parser/skipSpaces.ts

@@ -1,17 +0,0 @@
-import isSpace from './isSpace';
-import type PathParser from './pathParser';
-
-/**
- * Points the parser to the next character in the
- * path string every time it encounters any kind of
- * space character.
- *
- * @param path the `PathParser` instance
- */
-const skipSpaces = (path: PathParser) => {
-  const { pathValue, max } = path;
-  while (path.index < max && isSpace(pathValue.charCodeAt(path.index))) {
-    path.index += 1;
-  }
-};
-export default skipSpaces;

package/src/process/absolutizeSegment.ts

@@ -1,63 +0,0 @@
-import type {
-  AbsoluteSegment,
-  AbsoluteCommand,
-  ASegment,
-  VSegment,
-  HSegment,
-  QSegment,
-  SSegment,
-  TSegment,
-  CSegment,
-  PathSegment,
-  MSegment,
-  LSegment,
-} from '../types';
-
-/**
- * Returns an absolute segment of a `PathArray` object.
- *
- * @param segment the segment object
- * @param index the segment index
- * @param lastX the last known X value
- * @param lastY the last known Y value
- * @returns the absolute segment
- */
-const absolutizeSegment = (segment: PathSegment, index: number, lastX: number, lastY: number) => {
-  const [pathCommand] = segment;
-  const absCommand = pathCommand.toUpperCase() as AbsoluteCommand;
-  const isAbsolute = absCommand === pathCommand;
-
-  /* istanbul ignore else @preserve */
-  if (index === 0 || isAbsolute) return segment as MSegment | AbsoluteSegment;
-  // const values = segment.slice(1) as number[];
-  if (absCommand === 'A') {
-    return [
-      absCommand,
-      segment[1],
-      segment[2],
-      segment[3],
-      segment[4],
-      segment[5],
-      (segment as ASegment)[6] + lastX,
-      (segment as ASegment)[7] + lastY,
-    ] as ASegment;
-  } else if (absCommand === 'V') {
-    return [absCommand, (segment as VSegment)[1] + lastY] as VSegment;
-  } else if (absCommand === 'H') {
-    return [absCommand, (segment as HSegment)[1] + lastX] as HSegment;
-  } else if (absCommand === 'L') {
-    return [absCommand, (segment as LSegment)[1] + lastX, (segment as LSegment)[2] + lastY] as LSegment;
-  } else {
-    // use brakets for `eslint: no-case-declaration`
-    // https://stackoverflow.com/a/50753272/803358
-    const absValues = (segment.slice(1) as number[]).map((n, j) => n + (j % 2 ? lastY : lastX));
-    // for c, s, q, t
-    return [absCommand as typeof absCommand | number].concat(absValues) as
-      | MSegment
-      | QSegment
-      | TSegment
-      | SSegment
-      | CSegment;
-  }
-};
-export default absolutizeSegment;

package/src/process/arcToCubic.ts

@@ -1,128 +0,0 @@
-import rotateVector from '../math/rotateVector';
-
-/**
- * Converts A (arc-to) segments to C (cubic-bezier-to).
- *
- * For more information of where this math came from visit:
- * http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes
- *
- * @param X1 the starting x position
- * @param Y1 the starting y position
- * @param RX x-radius of the arc
- * @param RY y-radius of the arc
- * @param angle x-axis-rotation of the arc
- * @param LAF large-arc-flag of the arc
- * @param SF sweep-flag of the arc
- * @param X2 the ending x position
- * @param Y2 the ending y position
- * @param recursive the parameters needed to split arc into 2 segments
- * @return the resulting cubic-bezier segment(s)
- */
-const arcToCubic = (
-  X1: number,
-  Y1: number,
-  RX: number,
-  RY: number,
-  angle: number,
-  LAF: number,
-  SF: number,
-  X2: number,
-  Y2: number,
-  recursive?: [number, number, number, number],
-): number[] => {
-  let x1 = X1;
-  let y1 = Y1;
-  let rx = RX;
-  let ry = RY;
-  let x2 = X2;
-  let y2 = Y2;
-  // for more information of where this Math came from visit:
-  // http://www.w3.org/TR/SVG11/implnote.html#ArcImplementationNotes
-  const d120 = (Math.PI * 120) / 180;
-
-  const rad = (Math.PI / 180) * (+angle || 0);
-  let res = [] as number[];
-  let xy;
-  let f1;
-  let f2;
-  let cx;
-  let cy;
-
-  if (!recursive) {
-    xy = rotateVector(x1, y1, -rad);
-    x1 = xy.x;
-    y1 = xy.y;
-    xy = rotateVector(x2, y2, -rad);
-    x2 = xy.x;
-    y2 = xy.y;
-
-    const x = (x1 - x2) / 2;
-    const y = (y1 - y2) / 2;
-    let h = (x * x) / (rx * rx) + (y * y) / (ry * ry);
-    if (h > 1) {
-      h = Math.sqrt(h);
-      rx *= h;
-      ry *= h;
-    }
-    const rx2 = rx * rx;
-    const ry2 = ry * ry;
-
-    const k =
-      (LAF === SF ? -1 : 1) *
-      Math.sqrt(Math.abs((rx2 * ry2 - rx2 * y * y - ry2 * x * x) / (rx2 * y * y + ry2 * x * x)));
-
-    cx = (k * rx * y) / ry + (x1 + x2) / 2;
-    cy = (k * -ry * x) / rx + (y1 + y2) / 2;
-    // eslint-disable-next-line no-bitwise -- Impossible to satisfy no-bitwise
-    f1 = Math.asin(((((y1 - cy) / ry) * 10 ** 9) >> 0) / 10 ** 9);
-    // eslint-disable-next-line no-bitwise -- Impossible to satisfy no-bitwise
-    f2 = Math.asin(((((y2 - cy) / ry) * 10 ** 9) >> 0) / 10 ** 9);
-
-    f1 = x1 < cx ? Math.PI - f1 : f1;
-    f2 = x2 < cx ? Math.PI - f2 : f2;
-    if (f1 < 0) f1 = Math.PI * 2 + f1;
-    if (f2 < 0) f2 = Math.PI * 2 + f2;
-    if (SF && f1 > f2) {
-      f1 -= Math.PI * 2;
-    }
-    if (!SF && f2 > f1) {
-      f2 -= Math.PI * 2;
-    }
-  } else {
-    [f1, f2, cx, cy] = recursive;
-  }
-  let df = f2 - f1;
-  if (Math.abs(df) > d120) {
-    const f2old = f2;
-    const x2old = x2;
-    const y2old = y2;
-    f2 = f1 + d120 * (SF && f2 > f1 ? 1 : -1);
-    x2 = cx + rx * Math.cos(f2);
-    y2 = cy + ry * Math.sin(f2);
-    res = arcToCubic(x2, y2, rx, ry, angle, 0, SF, x2old, y2old, [f2, f2old, cx, cy]);
-  }
-  df = f2 - f1;
-  const c1 = Math.cos(f1);
-  const s1 = Math.sin(f1);
-  const c2 = Math.cos(f2);
-  const s2 = Math.sin(f2);
-  const t = Math.tan(df / 4);
-  const hx = (4 / 3) * rx * t;
-  const hy = (4 / 3) * ry * t;
-  const m1 = [x1, y1];
-  const m2 = [x1 + hx * s1, y1 - hy * c1];
-  const m3 = [x2 + hx * s2, y2 - hy * c2];
-  const m4 = [x2, y2];
-  m2[0] = 2 * m1[0] - m2[0];
-  m2[1] = 2 * m1[1] - m2[1];
-  if (recursive) {
-    return [m2[0], m2[1], m3[0], m3[1], m4[0], m4[1]].concat(res);
-  }
-  res = [m2[0], m2[1], m3[0], m3[1], m4[0], m4[1]].concat(res);
-  const newres = [];
-  for (let i = 0, ii = res.length; i < ii; i += 1) {
-    newres[i] = i % 2 ? rotateVector(res[i - 1], res[i], rad).y : rotateVector(res[i], res[i + 1], rad).x;
-  }
-  return newres;
-};
-export default arcToCubic;

package/src/process/getSVGMatrix.ts

@@ -1,70 +0,0 @@
-import CSSMatrix from '@thednp/dommatrix';
-// import type { TransformObject } from '../interface';
-import type { TransformObjectValues } from '../types';
-
-/**
- * Returns a transformation matrix to apply to `<path>` elements.
- *
- * @see TransformObjectValues
- *
- * @param transform the `transformObject`
- * @returns a new transformation matrix
- */
-const getSVGMatrix = (transform: TransformObjectValues): CSSMatrix => {
-  let matrix = new CSSMatrix();
-  const { origin } = transform;
-  const [originX, originY] = origin as [number, number, number];
-  const { translate } = transform;
-  const { rotate } = transform;
-  const { skew } = transform;
-  const { scale } = transform;
-
-  // set translate
-  if (
-    Array.isArray(translate) &&
-    translate.length >= 2 &&
-    translate.every(x => !Number.isNaN(+x)) &&
-    translate.some(x => x !== 0)
-  ) {
-    matrix = matrix.translate(...(translate as [number, number, number?]));
-  } else if (typeof translate === 'number' && !Number.isNaN(translate)) {
-    matrix = matrix.translate(translate);
-  }
-
-  if (rotate || skew || scale) {
-    // set SVG transform-origin, always defined
-    matrix = matrix.translate(originX, originY);
-
-    // set rotation
-    if (
-      Array.isArray(rotate) &&
-      rotate.length >= 2 &&
-      rotate.every(x => !Number.isNaN(+x)) &&
-      rotate.some(x => x !== 0)
-    ) {
-      matrix = matrix.rotate(...(rotate as [number, number, number?]));
-    } else if (typeof rotate === 'number' && !Number.isNaN(rotate)) {
-      matrix = matrix.rotate(rotate);
-    }
-
-    // set skew(s)
-    if (Array.isArray(skew) && skew.length === 2 && skew.every(x => !Number.isNaN(+x)) && skew.some(x => x !== 0)) {
-      matrix = skew[0] ? matrix.skewX(skew[0]) : matrix;
-      matrix = skew[1] ? matrix.skewY(skew[1]) : matrix;
-    } else if (typeof skew === 'number' && !Number.isNaN(skew)) {
-      matrix = matrix.skewX(skew);
-    }
-
-    // set scale
-    if (Array.isArray(scale) && scale.length >= 2 && scale.every(x => !Number.isNaN(+x)) && scale.some(x => x !== 1)) {
-      matrix = matrix.scale(...(scale as [number, number, number?]));
-    } else if (typeof scale === 'number' && !Number.isNaN(scale)) {
-      matrix = matrix.scale(scale);
-    }
-    // set SVG transform-origin
-    matrix = matrix.translate(-originX, -originY);
-  }
-
-  return matrix;
-};
-export default getSVGMatrix;

package/src/process/iterate.ts

@@ -1,58 +0,0 @@
-// import paramsParser from '../parser/paramsParser';
-import type { PathArray, PathCommand, PathSegment, IteratorCallback, AbsoluteCommand } from '../types';
-
-const iterate = <T extends PathArray>(path: PathArray, iterator: IteratorCallback) => {
-  let pathLen = path.length;
-  let segment: PathSegment;
-  let pathCommand = 'M' as PathCommand;
-  let absCommand = 'M' as AbsoluteCommand;
-  let isRelative = false;
-  let x = 0;
-  let y = 0;
-  let mx = 0;
-  let my = 0;
-  let segLen = 0;
-
-  for (let i = 0; i < pathLen; i += 1) {
-    segment = path[i];
-    [pathCommand] = segment;
-    segLen = segment.length;
-    absCommand = pathCommand.toUpperCase() as AbsoluteCommand;
-    isRelative = absCommand !== pathCommand;
-
-    const iteratorResult = iterator(segment, i, x, y);
-    // some methods like getPointAtLength would like to break
-    // when task is complete
-    if (iteratorResult === false) {
-      break;
-    }
-
-    // segment = path[i];
-    if (absCommand === 'Z') {
-      x = mx;
-      y = my;
-    } else if (absCommand === 'H') {
-      x = (segment[1] as number) + (isRelative ? x : 0);
-    } else if (absCommand === 'V') {
-      y = (segment[1] as number) + (isRelative ? y : 0);
-    } else {
-      x = (segment[segLen - 2] as number) + (isRelative ? x : 0);
-      y = (segment[segLen - 1] as number) + (isRelative ? y : 0);
-
-      if (absCommand === 'M') {
-        mx = x;
-        my = y;
-      }
-    }
-
-    if (iteratorResult) {
-      path[i] = iteratorResult;
-      if (iteratorResult[0] === 'C') {
-        pathLen = path.length;
-      }
-    }
-  }
-  return path as T;
-};
-
-export default iterate;

package/src/process/lineToCubic.ts

@@ -1,17 +0,0 @@
-import midPoint from '../math/midPoint';
-
-/**
- * Converts an L (line-to) segment to C (cubic-bezier).
- *
- * @param x1 line start x
- * @param y1 line start y
- * @param x2 line end x
- * @param y2 line end y
- * @returns the cubic-bezier segment
- */
-const lineToCubic = (x1: number, y1: number, x2: number, y2: number) => {
-  const c1 = midPoint([x1, y1], [x2, y2], 1.0 / 3.0);
-  const c2 = midPoint([x1, y1], [x2, y2], 2.0 / 3.0);
-  return [c1[0], c1[1], c2[0], c2[1], x2, y2];
-};
-export default lineToCubic;

package/src/process/normalizePath.ts

@@ -1,33 +0,0 @@
-import normalizeSegment from './normalizeSegment';
-import type { NormalArray, PathArray } from '../types';
-import iterate from './iterate';
-import parsePathString from '../parser/parsePathString';
-import paramsParser from '../parser/paramsParser';
-
-/**
- * Normalizes a `pathArray` object for further processing:
- * * convert segments to absolute values
- * * convert shorthand path commands to their non-shorthand notation
- *
- * @param pathInput the string to be parsed or 'pathArray'
- * @returns the normalized `pathArray`
- */
-const normalizePath = (pathInput: string | PathArray) => {
-  const path = parsePathString(pathInput);
-  const params = { ...paramsParser };
-
-  return iterate<NormalArray>(path, (seg, _, lastX, lastY) => {
-    params.x = lastX;
-    params.y = lastY;
-    const result = normalizeSegment(seg, params);
-
-    const seglen = result.length;
-    params.x1 = +result[seglen - 2];
-    params.y1 = +result[seglen - 1];
-    params.x2 = +result[seglen - 4] || params.x1;
-    params.y2 = +result[seglen - 3] || params.y1;
-
-    return result;
-  });
-};
-export default normalizePath;

package/src/process/normalizeSegment.ts

@@ -1,84 +0,0 @@
-import type { ParserParams } from '../interface';
-import type {
-  NormalSegment,
-  PointTuple,
-  PathSegment,
-  QSegment,
-  CSegment,
-  LSegment,
-  MSegment,
-  HSegment,
-  VSegment,
-  ASegment,
-  PathCommand,
-} from '../types';
-
-/**
- * Normalizes a single segment of a `pathArray` object.
- *
- * @param segment the segment object
- * @param params the normalization parameters
- * @returns the normalized segment
- */
-const normalizeSegment = (segment: PathSegment, params: ParserParams) => {
-  const [pathCommand] = segment;
-  const absCommand = pathCommand.toUpperCase();
-  const isRelative = pathCommand !== absCommand;
-  const { x1: px1, y1: py1, x2: px2, y2: py2, x, y } = params;
-  const values = segment.slice(1) as number[];
-  let absValues = values.map((n, j) => n + (isRelative ? (j % 2 ? y : x) : 0));
-
-  if (!'TQ'.includes(absCommand)) {
-    // optional but good to be cautious
-    params.qx = null;
-    params.qy = null;
-  }
-
-  // istanbul ignore else @preserve
-  if (absCommand === 'A') {
-    absValues = values.slice(0, -2).concat(values[5] + (isRelative ? x : 0), values[6] + (isRelative ? y : 0));
-
-    return ['A' as PathCommand | number].concat(absValues) as ASegment;
-  } else if (absCommand === 'H') {
-    return ['L', (segment as HSegment)[1] + (isRelative ? x : 0), py1] as LSegment;
-  } else if (absCommand === 'V') {
-    return ['L', px1, (segment as VSegment)[1] + (isRelative ? y : 0)] as LSegment;
-  } else if (absCommand === 'L') {
-    return [
-      'L',
-      (segment as LSegment)[1] + (isRelative ? x : 0),
-      (segment as LSegment)[2] + (isRelative ? y : 0),
-    ] as LSegment;
-  } else if (absCommand === 'M') {
-    return [
-      'M',
-      (segment as MSegment)[1] + (isRelative ? x : 0),
-      (segment as MSegment)[2] + (isRelative ? y : 0),
-    ] as MSegment;
-  } else if (absCommand === 'C') {
-    return ['C' as PathCommand | number].concat(absValues) as CSegment;
-  } else if (absCommand === 'S') {
-    const x1 = px1 * 2 - px2;
-    const y1 = py1 * 2 - py2;
-    params.x1 = x1;
-    params.y1 = y1;
-    return ['C', x1, y1].concat(absValues) as CSegment;
-  } else if (absCommand === 'T') {
-    const qx = px1 * 2 - (params.qx ? params.qx : /* istanbul ignore next */ 0);
-    const qy = py1 * 2 - (params.qy ? params.qy : /* istanbul ignore next */ 0);
-    params.qx = qx;
-    params.qy = qy;
-    return ['Q', qx, qy].concat(absValues) as QSegment;
-  } else if (absCommand === 'Q') {
-    const [nqx, nqy] = absValues as PointTuple;
-    params.qx = nqx;
-    params.qy = nqy;
-    return ['Q' as PathCommand | number].concat(absValues) as QSegment;
-  } else if (absCommand === 'Z') {
-    return ['Z'] as NormalSegment;
-  }
-
-  // istanbul ignore next @preserve
-  return segment as NormalSegment;
-};
-export default normalizeSegment;