@corellium/corellium-cli 1.2.0 → 1.2.1

package/node_modules/@jridgewell/trace-mapping/dist/types/trace-mapping.d.ts

@@ -1,74 +0,0 @@
-import type { SourceMapSegment } from './sourcemap-segment';
-import type { SourceMapV3, DecodedSourceMap, EncodedSourceMap, InvalidOriginalMapping, OriginalMapping, InvalidGeneratedMapping, GeneratedMapping, SourceMapInput, Needle, SourceNeedle, SourceMap, EachMapping } from './types';
-export type { SourceMapSegment } from './sourcemap-segment';
-export type { SourceMapInput, SectionedSourceMapInput, DecodedSourceMap, EncodedSourceMap, SectionedSourceMap, InvalidOriginalMapping, OriginalMapping as Mapping, OriginalMapping, InvalidGeneratedMapping, GeneratedMapping, EachMapping, } from './types';
-export declare const LEAST_UPPER_BOUND = -1;
-export declare const GREATEST_LOWER_BOUND = 1;
-/**
- * Returns the encoded (VLQ string) form of the SourceMap's mappings field.
- */
-export declare let encodedMappings: (map: TraceMap) => EncodedSourceMap['mappings'];
-/**
- * Returns the decoded (array of lines of segments) form of the SourceMap's mappings field.
- */
-export declare let decodedMappings: (map: TraceMap) => Readonly<DecodedSourceMap['mappings']>;
-/**
- * A low-level API to find the segment associated with a generated line/column (think, from a
- * stack trace). Line and column here are 0-based, unlike `originalPositionFor`.
- */
-export declare let traceSegment: (map: TraceMap, line: number, column: number) => Readonly<SourceMapSegment> | null;
-/**
- * A higher-level API to find the source/line/column associated with a generated line/column
- * (think, from a stack trace). Line is 1-based, but column is 0-based, due to legacy behavior in
- * `source-map` library.
- */
-export declare let originalPositionFor: (map: TraceMap, needle: Needle) => OriginalMapping | InvalidOriginalMapping;
-/**
- * Finds the source/line/column directly after the mapping returned by originalPositionFor, provided
- * the found mapping is from the same source and line as the originalPositionFor mapping.
- *
- * Eg, in the code `let id = 1`, `originalPositionAfter` could find the mapping associated with `1`
- * using the same needle that would return `id` when calling `originalPositionFor`.
- */
-export declare let generatedPositionFor: (map: TraceMap, needle: SourceNeedle) => GeneratedMapping | InvalidGeneratedMapping;
-/**
- * Iterates each mapping in generated position order.
- */
-export declare let eachMapping: (map: TraceMap, cb: (mapping: EachMapping) => void) => void;
-/**
- * Retrieves the source content for a particular source, if its found. Returns null if not.
- */
-export declare let sourceContentFor: (map: TraceMap, source: string) => string | null;
-/**
- * A helper that skips sorting of the input map's mappings array, which can be expensive for larger
- * maps.
- */
-export declare let presortedDecodedMap: (map: DecodedSourceMap, mapUrl?: string) => TraceMap;
-/**
- * Returns a sourcemap object (with decoded mappings) suitable for passing to a library that expects
- * a sourcemap, or to JSON.stringify.
- */
-export declare let decodedMap: (map: TraceMap) => Omit<DecodedSourceMap, 'mappings'> & {
-    mappings: readonly SourceMapSegment[][];
-};
-/**
- * Returns a sourcemap object (with encoded mappings) suitable for passing to a library that expects
- * a sourcemap, or to JSON.stringify.
- */
-export declare let encodedMap: (map: TraceMap) => EncodedSourceMap;
-export { AnyMap } from './any-map';
-export declare class TraceMap implements SourceMap {
-    version: SourceMapV3['version'];
-    file: SourceMapV3['file'];
-    names: SourceMapV3['names'];
-    sourceRoot: SourceMapV3['sourceRoot'];
-    sources: SourceMapV3['sources'];
-    sourcesContent: SourceMapV3['sourcesContent'];
-    resolvedSources: string[];
-    private _encoded;
-    private _decoded;
-    private _decodedMemo;
-    private _bySources;
-    private _bySourceMemos;
-    constructor(map: SourceMapInput, mapUrl?: string | null);
-}

package/node_modules/@jridgewell/trace-mapping/dist/types/types.d.ts

@@ -1,85 +0,0 @@
-import type { SourceMapSegment } from './sourcemap-segment';
-import type { TraceMap } from './trace-mapping';
-export interface SourceMapV3 {
-    file?: string | null;
-    names: string[];
-    sourceRoot?: string;
-    sources: (string | null)[];
-    sourcesContent?: (string | null)[];
-    version: 3;
-}
-export interface EncodedSourceMap extends SourceMapV3 {
-    mappings: string;
-}
-export interface DecodedSourceMap extends SourceMapV3 {
-    mappings: SourceMapSegment[][];
-}
-export interface Section {
-    offset: {
-        line: number;
-        column: number;
-    };
-    map: EncodedSourceMap | DecodedSourceMap | SectionedSourceMap;
-}
-export interface SectionedSourceMap {
-    file?: string | null;
-    sections: Section[];
-    version: 3;
-}
-export declare type OriginalMapping = {
-    source: string | null;
-    line: number;
-    column: number;
-    name: string | null;
-};
-export declare type InvalidOriginalMapping = {
-    source: null;
-    line: null;
-    column: null;
-    name: null;
-};
-export declare type GeneratedMapping = {
-    line: number;
-    column: number;
-};
-export declare type InvalidGeneratedMapping = {
-    line: null;
-    column: null;
-};
-export declare type SourceMapInput = string | EncodedSourceMap | DecodedSourceMap | TraceMap;
-export declare type SectionedSourceMapInput = SourceMapInput | SectionedSourceMap;
-export declare type Needle = {
-    line: number;
-    column: number;
-    bias?: 1 | -1;
-};
-export declare type SourceNeedle = {
-    source: string;
-    line: number;
-    column: number;
-    bias?: 1 | -1;
-};
-export declare type EachMapping = {
-    generatedLine: number;
-    generatedColumn: number;
-    source: null;
-    originalLine: null;
-    originalColumn: null;
-    name: null;
-} | {
-    generatedLine: number;
-    generatedColumn: number;
-    source: string | null;
-    originalLine: number;
-    originalColumn: number;
-    name: string | null;
-};
-export declare abstract class SourceMap {
-    version: SourceMapV3['version'];
-    file: SourceMapV3['file'];
-    names: SourceMapV3['names'];
-    sourceRoot: SourceMapV3['sourceRoot'];
-    sources: SourceMapV3['sources'];
-    sourcesContent: SourceMapV3['sourcesContent'];
-    resolvedSources: SourceMapV3['sources'];
-}

package/node_modules/@jridgewell/trace-mapping/package.json

@@ -1,112 +0,0 @@
-{
-  "_args": [
-    [
-      "@jridgewell/trace-mapping@0.3.14",
-      "/home/sam/source/corellium/corellium-cli"
-    ]
-  ],
-  "_from": "@jridgewell/trace-mapping@0.3.14",
-  "_id": "@jridgewell/trace-mapping@0.3.14",
-  "_inBundle": false,
-  "_integrity": "sha512-bJWEfQ9lPTvm3SneWwRFVLzrh6nhjwqw7TUFFBEMzwvg7t7PCDenf2lDwqo4NQXzdpgBXyFgDWnQA+2vkruksQ==",
-  "_location": "/@jridgewell/trace-mapping",
-  "_phantomChildren": {},
-  "_requested": {
-    "type": "version",
-    "registry": true,
-    "raw": "@jridgewell/trace-mapping@0.3.14",
-    "name": "@jridgewell/trace-mapping",
-    "escapedName": "@jridgewell%2ftrace-mapping",
-    "scope": "@jridgewell",
-    "rawSpec": "0.3.14",
-    "saveSpec": null,
-    "fetchSpec": "0.3.14"
-  },
-  "_requiredBy": [
-    "/@babel/cli"
-  ],
-  "_resolved": "https://registry.npmjs.org/@jridgewell/trace-mapping/-/trace-mapping-0.3.14.tgz",
-  "_spec": "0.3.14",
-  "_where": "/home/sam/source/corellium/corellium-cli",
-  "author": {
-    "name": "Justin Ridgewell",
-    "email": "justin@ridgewell.name"
-  },
-  "bugs": {
-    "url": "https://github.com/jridgewell/trace-mapping/issues"
-  },
-  "dependencies": {
-    "@jridgewell/resolve-uri": "^3.0.3",
-    "@jridgewell/sourcemap-codec": "^1.4.10"
-  },
-  "description": "Trace the original position through a source map",
-  "devDependencies": {
-    "@rollup/plugin-typescript": "8.3.2",
-    "@typescript-eslint/eslint-plugin": "5.23.0",
-    "@typescript-eslint/parser": "5.23.0",
-    "ava": "4.2.0",
-    "benchmark": "2.1.4",
-    "c8": "7.11.2",
-    "esbuild": "0.14.38",
-    "esbuild-node-loader": "0.8.0",
-    "eslint": "8.15.0",
-    "eslint-config-prettier": "8.5.0",
-    "eslint-plugin-no-only-tests": "2.6.0",
-    "npm-run-all": "4.1.5",
-    "prettier": "2.6.2",
-    "rollup": "2.72.1",
-    "typescript": "4.6.4"
-  },
-  "exports": {
-    ".": [
-      {
-        "types": "./dist/types/trace-mapping.d.ts",
-        "browser": "./dist/trace-mapping.umd.js",
-        "require": "./dist/trace-mapping.umd.js",
-        "import": "./dist/trace-mapping.mjs"
-      },
-      "./dist/trace-mapping.umd.js"
-    ],
-    "./package.json": "./package.json"
-  },
-  "files": [
-    "dist",
-    "src"
-  ],
-  "homepage": "https://github.com/jridgewell/trace-mapping#readme",
-  "keywords": [
-    "source",
-    "map"
-  ],
-  "license": "MIT",
-  "main": "dist/trace-mapping.umd.js",
-  "module": "dist/trace-mapping.mjs",
-  "name": "@jridgewell/trace-mapping",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/jridgewell/trace-mapping.git"
-  },
-  "scripts": {
-    "benchmark": "run-s build:rollup benchmark:*",
-    "benchmark:install": "cd benchmark && npm install",
-    "benchmark:only": "node --expose-gc benchmark/index.mjs",
-    "build": "run-s -n build:*",
-    "build:rollup": "rollup -c rollup.config.js",
-    "build:ts": "tsc --project tsconfig.build.json",
-    "lint": "run-s -n lint:*",
-    "lint:prettier": "npm run test:lint:prettier -- --write",
-    "lint:ts": "npm run test:lint:ts -- --fix",
-    "prebuild": "rm -rf dist",
-    "prepublishOnly": "npm run preversion",
-    "preversion": "run-s test build",
-    "test": "run-s -n test:lint test:only",
-    "test:debug": "ava debug",
-    "test:lint": "run-s -n test:lint:*",
-    "test:lint:prettier": "prettier --check '{src,test}/**/*.ts' '**/*.md'",
-    "test:lint:ts": "eslint '{src,test}/**/*.ts'",
-    "test:only": "c8 ava",
-    "test:watch": "ava --watch"
-  },
-  "typings": "dist/types/trace-mapping.d.ts",
-  "version": "0.3.14"
-}

package/node_modules/@jridgewell/trace-mapping/src/any-map.ts

@@ -1,166 +0,0 @@
-import { TraceMap, presortedDecodedMap, decodedMappings } from './trace-mapping';
-import {
-  COLUMN,
-  SOURCES_INDEX,
-  SOURCE_LINE,
-  SOURCE_COLUMN,
-  NAMES_INDEX,
-} from './sourcemap-segment';
-
-import type {
-  Section,
-  SectionedSourceMap,
-  DecodedSourceMap,
-  SectionedSourceMapInput,
-} from './types';
-import type { SourceMapSegment } from './sourcemap-segment';
-
-type AnyMap = {
-  new (map: SectionedSourceMapInput, mapUrl?: string | null): TraceMap;
-  (map: SectionedSourceMapInput, mapUrl?: string | null): TraceMap;
-};
-
-export const AnyMap: AnyMap = function (map, mapUrl) {
-  const parsed =
-    typeof map === 'string' ? (JSON.parse(map) as Exclude<SectionedSourceMapInput, string>) : map;
-
-  if (!('sections' in parsed)) return new TraceMap(parsed, mapUrl);
-
-  const mappings: SourceMapSegment[][] = [];
-  const sources: string[] = [];
-  const sourcesContent: (string | null)[] = [];
-  const names: string[] = [];
-
-  recurse(parsed, mapUrl, mappings, sources, sourcesContent, names, 0, 0, Infinity, Infinity);
-
-  const joined: DecodedSourceMap = {
-    version: 3,
-    file: parsed.file,
-    names,
-    sources,
-    sourcesContent,
-    mappings,
-  };
-
-  return presortedDecodedMap(joined);
-} as AnyMap;
-
-function recurse(
-  input: SectionedSourceMap,
-  mapUrl: string | null | undefined,
-  mappings: SourceMapSegment[][],
-  sources: string[],
-  sourcesContent: (string | null)[],
-  names: string[],
-  lineOffset: number,
-  columnOffset: number,
-  stopLine: number,
-  stopColumn: number,
-) {
-  const { sections } = input;
-  for (let i = 0; i < sections.length; i++) {
-    const { map, offset } = sections[i];
-
-    let sl = stopLine;
-    let sc = stopColumn;
-    if (i + 1 < sections.length) {
-      const nextOffset = sections[i + 1].offset;
-      sl = Math.min(stopLine, lineOffset + nextOffset.line);
-
-      if (sl === stopLine) {
-        sc = Math.min(stopColumn, columnOffset + nextOffset.column);
-      } else if (sl < stopLine) {
-        sc = columnOffset + nextOffset.column;
-      }
-    }
-
-    addSection(
-      map,
-      mapUrl,
-      mappings,
-      sources,
-      sourcesContent,
-      names,
-      lineOffset + offset.line,
-      columnOffset + offset.column,
-      sl,
-      sc,
-    );
-  }
-}
-
-function addSection(
-  input: Section['map'],
-  mapUrl: string | null | undefined,
-  mappings: SourceMapSegment[][],
-  sources: string[],
-  sourcesContent: (string | null)[],
-  names: string[],
-  lineOffset: number,
-  columnOffset: number,
-  stopLine: number,
-  stopColumn: number,
-) {
-  if ('sections' in input) return recurse(...(arguments as unknown as Parameters<typeof recurse>));
-
-  const map = new TraceMap(input, mapUrl);
-  const sourcesOffset = sources.length;
-  const namesOffset = names.length;
-  const decoded = decodedMappings(map);
-  const { resolvedSources, sourcesContent: contents } = map;
-
-  append(sources, resolvedSources);
-  append(names, map.names);
-  if (contents) append(sourcesContent, contents);
-  else for (let i = 0; i < resolvedSources.length; i++) sourcesContent.push(null);
-
-  for (let i = 0; i < decoded.length; i++) {
-    const lineI = lineOffset + i;
-
-    // We can only add so many lines before we step into the range that the next section's map
-    // controls. When we get to the last line, then we'll start checking the segments to see if
-    // they've crossed into the column range. But it may not have any columns that overstep, so we
-    // still need to check that we don't overstep lines, too.
-    if (lineI > stopLine) return;
-
-    // The out line may already exist in mappings (if we're continuing the line started by a
-    // previous section). Or, we may have jumped ahead several lines to start this section.
-    const out = getLine(mappings, lineI);
-    // On the 0th loop, the section's column offset shifts us forward. On all other lines (since the
-    // map can be multiple lines), it doesn't.
-    const cOffset = i === 0 ? columnOffset : 0;
-
-    const line = decoded[i];
-    for (let j = 0; j < line.length; j++) {
-      const seg = line[j];
-      const column = cOffset + seg[COLUMN];
-
-      // If this segment steps into the column range that the next section's map controls, we need
-      // to stop early.
-      if (lineI === stopLine && column >= stopColumn) return;
-
-      if (seg.length === 1) {
-        out.push([column]);
-        continue;
-      }
-
-      const sourcesIndex = sourcesOffset + seg[SOURCES_INDEX];
-      const sourceLine = seg[SOURCE_LINE];
-      const sourceColumn = seg[SOURCE_COLUMN];
-      out.push(
-        seg.length === 4
-          ? [column, sourcesIndex, sourceLine, sourceColumn]
-          : [column, sourcesIndex, sourceLine, sourceColumn, namesOffset + seg[NAMES_INDEX]],
-      );
-    }
-  }
-}
-
-function append<T>(arr: T[], other: T[]) {
-  for (let i = 0; i < other.length; i++) arr.push(other[i]);
-}
-
-function getLine<T>(arr: T[][], index: number): T[] {
-  for (let i = arr.length; i <= index; i++) arr[i] = [];
-  return arr[index];
-}

package/node_modules/@jridgewell/trace-mapping/src/binary-search.ts

@@ -1,115 +0,0 @@
-import type { SourceMapSegment, ReverseSegment } from './sourcemap-segment';
-import { COLUMN } from './sourcemap-segment';
-
-export type MemoState = {
-  lastKey: number;
-  lastNeedle: number;
-  lastIndex: number;
-};
-
-export let found = false;
-
-/**
- * A binary search implementation that returns the index if a match is found.
- * If no match is found, then the left-index (the index associated with the item that comes just
- * before the desired index) is returned. To maintain proper sort order, a splice would happen at
- * the next index:
- *
- * ```js
- * const array = [1, 3];
- * const needle = 2;
- * const index = binarySearch(array, needle, (item, needle) => item - needle);
- *
- * assert.equal(index, 0);
- * array.splice(index + 1, 0, needle);
- * assert.deepEqual(array, [1, 2, 3]);
- * ```
- */
-export function binarySearch(
-  haystack: SourceMapSegment[] | ReverseSegment[],
-  needle: number,
-  low: number,
-  high: number,
-): number {
-  while (low <= high) {
-    const mid = low + ((high - low) >> 1);
-    const cmp = haystack[mid][COLUMN] - needle;
-
-    if (cmp === 0) {
-      found = true;
-      return mid;
-    }
-
-    if (cmp < 0) {
-      low = mid + 1;
-    } else {
-      high = mid - 1;
-    }
-  }
-
-  found = false;
-  return low - 1;
-}
-
-export function upperBound(
-  haystack: SourceMapSegment[] | ReverseSegment[],
-  needle: number,
-  index: number,
-): number {
-  for (let i = index + 1; i < haystack.length; index = i++) {
-    if (haystack[i][COLUMN] !== needle) break;
-  }
-  return index;
-}
-
-export function lowerBound(
-  haystack: SourceMapSegment[] | ReverseSegment[],
-  needle: number,
-  index: number,
-): number {
-  for (let i = index - 1; i >= 0; index = i--) {
-    if (haystack[i][COLUMN] !== needle) break;
-  }
-  return index;
-}
-
-export function memoizedState(): MemoState {
-  return {
-    lastKey: -1,
-    lastNeedle: -1,
-    lastIndex: -1,
-  };
-}
-
-/**
- * This overly complicated beast is just to record the last tested line/column and the resulting
- * index, allowing us to skip a few tests if mappings are monotonically increasing.
- */
-export function memoizedBinarySearch(
-  haystack: SourceMapSegment[] | ReverseSegment[],
-  needle: number,
-  state: MemoState,
-  key: number,
-): number {
-  const { lastKey, lastNeedle, lastIndex } = state;
-
-  let low = 0;
-  let high = haystack.length - 1;
-  if (key === lastKey) {
-    if (needle === lastNeedle) {
-      found = lastIndex !== -1 && haystack[lastIndex][COLUMN] === needle;
-      return lastIndex;
-    }
-
-    if (needle >= lastNeedle) {
-      // lastIndex may be -1 if the previous needle was not found.
-      low = lastIndex === -1 ? 0 : lastIndex;
-    } else {
-      high = lastIndex;
-    }
-  }
-  state.lastKey = key;
-  state.lastNeedle = needle;
-
-  return (state.lastIndex = binarySearch(haystack, needle, low, high));
-}

package/node_modules/@jridgewell/trace-mapping/src/by-source.ts

@@ -1,64 +0,0 @@
-import { COLUMN, SOURCES_INDEX, SOURCE_LINE, SOURCE_COLUMN } from './sourcemap-segment';
-import { memoizedBinarySearch, upperBound } from './binary-search';
-
-import type { ReverseSegment, SourceMapSegment } from './sourcemap-segment';
-import type { MemoState } from './binary-search';
-
-export type Source = {
-  __proto__: null;
-  [line: number]: Exclude<ReverseSegment, [number]>[];
-};
-
-// Rebuilds the original source files, with mappings that are ordered by source line/column instead
-// of generated line/column.
-export default function buildBySources(
-  decoded: readonly SourceMapSegment[][],
-  memos: MemoState[],
-): Source[] {
-  const sources: Source[] = memos.map(buildNullArray);
-
-  for (let i = 0; i < decoded.length; i++) {
-    const line = decoded[i];
-    for (let j = 0; j < line.length; j++) {
-      const seg = line[j];
-      if (seg.length === 1) continue;
-
-      const sourceIndex = seg[SOURCES_INDEX];
-      const sourceLine = seg[SOURCE_LINE];
-      const sourceColumn = seg[SOURCE_COLUMN];
-      const originalSource = sources[sourceIndex];
-      const originalLine = (originalSource[sourceLine] ||= []);
-      const memo = memos[sourceIndex];
-
-      // The binary search either found a match, or it found the left-index just before where the
-      // segment should go. Either way, we want to insert after that. And there may be multiple
-      // generated segments associated with an original location, so there may need to move several
-      // indexes before we find where we need to insert.
-      const index = upperBound(
-        originalLine,
-        sourceColumn,
-        memoizedBinarySearch(originalLine, sourceColumn, memo, sourceLine),
-      );
-
-      insert(originalLine, (memo.lastIndex = index + 1), [sourceColumn, i, seg[COLUMN]]);
-    }
-  }
-
-  return sources;
-}
-
-function insert<T>(array: T[], index: number, value: T) {
-  for (let i = array.length; i > index; i--) {
-    array[i] = array[i - 1];
-  }
-  array[index] = value;
-}
-
-// Null arrays allow us to use ordered index keys without actually allocating contiguous memory like
-// a real array. We use a null-prototype object to avoid prototype pollution and deoptimizations.
-// Numeric properties on objects are magically sorted in ascending order by the engine regardless of
-// the insertion order. So, by setting any numeric keys, even out of order, we'll get ascending
-// order when iterating with for-in.
-function buildNullArray<T extends { __proto__: null }>(): T {
-  return { __proto__: null } as T;
-}

package/node_modules/@jridgewell/trace-mapping/src/resolve.ts

@@ -1,10 +0,0 @@
-import resolveUri from '@jridgewell/resolve-uri';
-
-export default function resolve(input: string, base: string | undefined): string {
-  // The base is always treated as a directory, if it's not empty.
-  // https://github.com/mozilla/source-map/blob/8cb3ee57/lib/util.js#L327
-  // https://github.com/chromium/chromium/blob/da4adbb3/third_party/blink/renderer/devtools/front_end/sdk/SourceMap.js#L400-L401
-  if (base && !base.endsWith('/')) base += '/';
-
-  return resolveUri(input, base);
-}

package/node_modules/@jridgewell/trace-mapping/src/sort.ts

@@ -1,45 +0,0 @@
-import { COLUMN } from './sourcemap-segment';
-
-import type { SourceMapSegment } from './sourcemap-segment';
-
-export default function maybeSort(
-  mappings: SourceMapSegment[][],
-  owned: boolean,
-): SourceMapSegment[][] {
-  const unsortedIndex = nextUnsortedSegmentLine(mappings, 0);
-  if (unsortedIndex === mappings.length) return mappings;
-
-  // If we own the array (meaning we parsed it from JSON), then we're free to directly mutate it. If
-  // not, we do not want to modify the consumer's input array.
-  if (!owned) mappings = mappings.slice();
-
-  for (let i = unsortedIndex; i < mappings.length; i = nextUnsortedSegmentLine(mappings, i + 1)) {
-    mappings[i] = sortSegments(mappings[i], owned);
-  }
-  return mappings;
-}
-
-function nextUnsortedSegmentLine(mappings: SourceMapSegment[][], start: number): number {
-  for (let i = start; i < mappings.length; i++) {
-    if (!isSorted(mappings[i])) return i;
-  }
-  return mappings.length;
-}
-
-function isSorted(line: SourceMapSegment[]): boolean {
-  for (let j = 1; j < line.length; j++) {
-    if (line[j][COLUMN] < line[j - 1][COLUMN]) {
-      return false;
-    }
-  }
-  return true;
-}
-
-function sortSegments(line: SourceMapSegment[], owned: boolean): SourceMapSegment[] {
-  if (!owned) line = line.slice();
-  return line.sort(sortComparator);
-}
-
-function sortComparator(a: SourceMapSegment, b: SourceMapSegment): number {
-  return a[COLUMN] - b[COLUMN];
-}