metro-source-map 0.54.1 → 0.55.0

package/src/Consumer/MappingsConsumer.js.flow

@@ -0,0 +1,197 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow
+ * @format
+ */
+
+'use strict';
+
+const AbstractConsumer = require('./AbstractConsumer');
+
+const invariant = require('invariant');
+const normalizeSourcePath = require('./normalizeSourcePath');
+
+const {
+  FIRST_COLUMN,
+  FIRST_LINE,
+  GREATEST_LOWER_BOUND,
+  EMPTY_POSITION,
+  lookupBiasToString,
+} = require('./constants');
+const {greatestLowerBound} = require('./search');
+const {add, get0, add0, sub, inc} = require('ob1');
+const {decode: decodeVlq} = require('vlq');
+
+import type {BasicSourceMap} from '../source-map';
+import type {
+  SourcePosition,
+  GeneratedPositionLookup,
+  Mapping,
+  IConsumer,
+} from './types.flow';
+
+/**
+ * A source map consumer that supports "basic" source maps (that have a
+ * `mappings` field and no sections).
+ */
+class MappingsConsumer extends AbstractConsumer implements IConsumer {
+  _sourceMap: BasicSourceMap;
+  _decodedMappings: ?$ReadOnlyArray<Mapping>;
+  _normalizedSources: ?$ReadOnlyArray<string>;
+
+  constructor(sourceMap: BasicSourceMap) {
+    super(sourceMap);
+    this._sourceMap = sourceMap;
+    this._decodedMappings = null;
+    this._normalizedSources = null;
+  }
+
+  originalPositionFor(
+    generatedPosition: GeneratedPositionLookup,
+  ): SourcePosition {
+    const {line, column} = generatedPosition;
+    if (line == null || column == null) {
+      return {...EMPTY_POSITION};
+    }
+    if (generatedPosition.bias != null) {
+      invariant(
+        generatedPosition.bias === GREATEST_LOWER_BOUND,
+        `Unimplemented lookup bias: ${lookupBiasToString(
+          generatedPosition.bias,
+        )}`,
+      );
+    }
+    const mappings = this._decodeAndCacheMappings();
+    const index = greatestLowerBound(
+      mappings,
+      {line, column},
+      (position, mapping) => {
+        if (position.line === mapping.generatedLine) {
+          return get0(sub(position.column, mapping.generatedColumn));
+        }
+        return get0(sub(position.line, mapping.generatedLine));
+      },
+    );
+    if (
+      index != null &&
+      mappings[index].generatedLine === generatedPosition.line
+    ) {
+      const mapping = mappings[index];
+      return {
+        source: mapping.source,
+        name: mapping.name,
+        line: mapping.originalLine,
+        column: mapping.originalColumn,
+      };
+    }
+    return {...EMPTY_POSITION};
+  }
+
+  *_decodeMappings() {
+    let generatedLine = FIRST_LINE;
+    let generatedColumn = FIRST_COLUMN;
+    let originalLine = FIRST_LINE;
+    let originalColumn = FIRST_COLUMN;
+    let nameIndex = add0(0);
+    let sourceIndex = add0(0);
+
+    const normalizedSources = this._normalizeAndCacheSources();
+
+    const {mappings: mappingsRaw, names} = this._sourceMap;
+    let next;
+    const vlqCache = new Map();
+    for (let i = 0; i < mappingsRaw.length; i = next) {
+      switch (mappingsRaw[i]) {
+        case ';':
+          generatedLine = inc(generatedLine);
+          generatedColumn = FIRST_COLUMN;
+        /* falls through */
+        case ',':
+          next = i + 1;
+          continue;
+      }
+      findNext: for (next = i + 1; next < mappingsRaw.length; ++next) {
+        switch (mappingsRaw[next]) {
+          case ';':
+          /* falls through */
+          case ',':
+            break findNext;
+        }
+      }
+      const mappingRaw = mappingsRaw.slice(i, next);
+      let decodedVlqValues;
+      if (vlqCache.has(mappingRaw)) {
+        decodedVlqValues = vlqCache.get(mappingRaw);
+      } else {
+        decodedVlqValues = decodeVlq(mappingRaw);
+        vlqCache.set(mappingRaw, decodedVlqValues);
+      }
+      invariant(Array.isArray(decodedVlqValues), 'Decoding VLQ tuple failed');
+      const [
+        generatedColumnDelta,
+        sourceIndexDelta,
+        originalLineDelta,
+        originalColumnDelta,
+        nameIndexDelta,
+      ] = decodedVlqValues;
+      decodeVlq(mappingRaw);
+      invariant(generatedColumnDelta != null, 'Invalid generated column delta');
+      generatedColumn = add(generatedColumn, generatedColumnDelta);
+      const mapping: Mapping = {
+        generatedLine,
+        generatedColumn,
+        source: null,
+        name: null,
+        originalLine: null,
+        originalColumn: null,
+      };
+
+      if (sourceIndexDelta != null) {
+        sourceIndex = add(sourceIndex, sourceIndexDelta);
+        mapping.source = normalizedSources[get0(sourceIndex)];
+
+        invariant(originalLineDelta != null, 'Invalid original line delta');
+        invariant(originalColumnDelta != null, 'Invalid original column delta');
+
+        originalLine = add(originalLine, originalLineDelta);
+        originalColumn = add(originalColumn, originalColumnDelta);
+
+        mapping.originalLine = originalLine;
+        mapping.originalColumn = originalColumn;
+
+        if (nameIndexDelta != null) {
+          nameIndex = add(nameIndex, nameIndexDelta);
+          mapping.name = names[get0(nameIndex)];
+        }
+      }
+
+      yield mapping;
+    }
+  }
+
+  _normalizeAndCacheSources(): $ReadOnlyArray<string> {
+    if (!this._normalizedSources) {
+      this._normalizedSources = this._sourceMap.sources.map(source =>
+        normalizeSourcePath(source, this._sourceMap),
+      );
+    }
+    return this._normalizedSources;
+  }
+
+  _decodeAndCacheMappings(): $ReadOnlyArray<Mapping> {
+    if (!this._decodedMappings) {
+      this._decodedMappings = [...this._decodeMappings()];
+    }
+    return this._decodedMappings;
+  }
+
+  generatedMappings(): Iterable<Mapping> {
+    return this._decodeAndCacheMappings();
+  }
+}
+
+module.exports = MappingsConsumer;

package/src/Consumer/SectionsConsumer.js

@@ -0,0 +1,201 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *  strict-local
+ * @format
+ */
+"use strict";
+
+function _objectSpread(target) {
+  for (var i = 1; i < arguments.length; i++) {
+    var source = arguments[i] != null ? arguments[i] : {};
+    var ownKeys = Object.keys(source);
+    if (typeof Object.getOwnPropertySymbols === "function") {
+      ownKeys = ownKeys.concat(
+        Object.getOwnPropertySymbols(source).filter(function(sym) {
+          return Object.getOwnPropertyDescriptor(source, sym).enumerable;
+        })
+      );
+    }
+    ownKeys.forEach(function(key) {
+      _defineProperty(target, key, source[key]);
+    });
+  }
+  return target;
+}
+
+function _defineProperty(obj, key, value) {
+  if (key in obj) {
+    Object.defineProperty(obj, key, {
+      value: value,
+      enumerable: true,
+      configurable: true,
+      writable: true
+    });
+  } else {
+    obj[key] = value;
+  }
+  return obj;
+}
+
+function _slicedToArray(arr, i) {
+  return (
+    _arrayWithHoles(arr) || _iterableToArrayLimit(arr, i) || _nonIterableRest()
+  );
+}
+
+function _nonIterableRest() {
+  throw new TypeError("Invalid attempt to destructure non-iterable instance");
+}
+
+function _iterableToArrayLimit(arr, i) {
+  var _arr = [];
+  var _n = true;
+  var _d = false;
+  var _e = undefined;
+  try {
+    for (
+      var _i = arr[Symbol.iterator](), _s;
+      !(_n = (_s = _i.next()).done);
+      _n = true
+    ) {
+      _arr.push(_s.value);
+      if (i && _arr.length === i) break;
+    }
+  } catch (err) {
+    _d = true;
+    _e = err;
+  } finally {
+    try {
+      if (!_n && _i["return"] != null) _i["return"]();
+    } finally {
+      if (_d) throw _e;
+    }
+  }
+  return _arr;
+}
+
+function _arrayWithHoles(arr) {
+  if (Array.isArray(arr)) return arr;
+}
+
+const AbstractConsumer = require("./AbstractConsumer");
+
+const createConsumer = require("./createConsumer");
+
+const _require = require("./constants"),
+  FIRST_COLUMN = _require.FIRST_COLUMN,
+  FIRST_LINE = _require.FIRST_LINE,
+  EMPTY_POSITION = _require.EMPTY_POSITION;
+
+const _require2 = require("./positionMath"),
+  subtractOffsetFromPosition = _require2.subtractOffsetFromPosition;
+
+const _require3 = require("./search"),
+  greatestLowerBound = _require3.greatestLowerBound;
+
+const _require4 = require("ob1"),
+  add = _require4.add,
+  get0 = _require4.get0,
+  get1 = _require4.get1,
+  add0 = _require4.add0,
+  sub1 = _require4.sub1,
+  sub = _require4.sub;
+
+/**
+ * A source map consumer that supports "indexed" source maps (that have a
+ * `sections` field and no top-level mappings).
+ */
+class SectionsConsumer extends AbstractConsumer {
+  constructor(sourceMap) {
+    super(sourceMap);
+    this._consumers = sourceMap.sections.map((section, index) => {
+      const generatedOffset = {
+        lines: add0(section.offset.line),
+        columns: add0(section.offset.column)
+      };
+      const consumer = createConsumer(section.map);
+      return [generatedOffset, consumer];
+    });
+  }
+
+  originalPositionFor(generatedPosition) {
+    const _ref = this._consumerForPosition(generatedPosition) || [],
+      _ref2 = _slicedToArray(_ref, 2),
+      generatedOffset = _ref2[0],
+      consumer = _ref2[1];
+
+    if (!consumer) {
+      return EMPTY_POSITION;
+    }
+
+    return consumer.originalPositionFor(
+      subtractOffsetFromPosition(generatedPosition, generatedOffset)
+    );
+  }
+
+  *generatedMappings() {
+    for (const _ref3 of this._consumers) {
+      var _ref4 = _slicedToArray(_ref3, 2);
+
+      const generatedOffset = _ref4[0];
+      const consumer = _ref4[1];
+      let first = true;
+
+      for (const mapping of consumer.generatedMappings()) {
+        if (
+          first &&
+          (get1(mapping.generatedLine) > 1 || get0(mapping.generatedColumn) > 0)
+        ) {
+          yield {
+            generatedLine: FIRST_LINE,
+            generatedColumn: FIRST_COLUMN,
+            source: null,
+            name: null,
+            originalLine: null,
+            originalColumn: null
+          };
+        }
+
+        first = false;
+        yield _objectSpread({}, mapping, {
+          generatedLine: add(mapping.generatedLine, generatedOffset.lines),
+          generatedColumn: add(mapping.generatedColumn, generatedOffset.columns)
+        });
+      }
+    }
+  }
+
+  _consumerForPosition(generatedPosition) {
+    const line = generatedPosition.line,
+      column = generatedPosition.column;
+
+    if (line == null || column == null) {
+      return null;
+    }
+
+    const index = greatestLowerBound(
+      this._consumers,
+      generatedPosition,
+      (position, _ref5) => {
+        let _ref6 = _slicedToArray(_ref5, 1),
+          offset = _ref6[0];
+
+        const line0 = sub1(line);
+        const column0 = column;
+
+        if (line0 === offset.lines) {
+          return get0(sub(column0, offset.columns));
+        }
+
+        return get0(sub(line0, offset.lines));
+      }
+    );
+    return index != null ? this._consumers[index] : null;
+  }
+}
+
+module.exports = SectionsConsumer;

package/src/Consumer/SectionsConsumer.js.flow

@@ -0,0 +1,116 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+const AbstractConsumer = require('./AbstractConsumer');
+
+const createConsumer = require('./createConsumer');
+
+const {FIRST_COLUMN, FIRST_LINE, EMPTY_POSITION} = require('./constants');
+const {subtractOffsetFromPosition} = require('./positionMath');
+const {greatestLowerBound} = require('./search');
+const {add, get0, get1, add0, sub1, sub} = require('ob1');
+
+import type {IndexMap} from '../source-map';
+import type {
+  GeneratedOffset,
+  SourcePosition,
+  GeneratedPositionLookup,
+  Mapping,
+  IConsumer,
+} from './types.flow';
+
+/**
+ * A source map consumer that supports "indexed" source maps (that have a
+ * `sections` field and no top-level mappings).
+ */
+class SectionsConsumer extends AbstractConsumer implements IConsumer {
+  _consumers: $ReadOnlyArray<[GeneratedOffset, IConsumer]>;
+
+  constructor(sourceMap: IndexMap) {
+    super(sourceMap);
+    this._consumers = sourceMap.sections.map((section, index) => {
+      const generatedOffset = {
+        lines: add0(section.offset.line),
+        columns: add0(section.offset.column),
+      };
+      const consumer = createConsumer(section.map);
+      return [generatedOffset, consumer];
+    });
+  }
+
+  originalPositionFor(
+    generatedPosition: GeneratedPositionLookup,
+  ): SourcePosition {
+    const [generatedOffset, consumer] =
+      this._consumerForPosition(generatedPosition) || [];
+    if (!consumer) {
+      return EMPTY_POSITION;
+    }
+    return consumer.originalPositionFor(
+      subtractOffsetFromPosition(generatedPosition, generatedOffset),
+    );
+  }
+
+  *generatedMappings(): Iterable<Mapping> {
+    for (const [generatedOffset, consumer] of this._consumers) {
+      let first = true;
+      for (const mapping of consumer.generatedMappings()) {
+        if (
+          first &&
+          (get1(mapping.generatedLine) > 1 || get0(mapping.generatedColumn) > 0)
+        ) {
+          yield {
+            generatedLine: FIRST_LINE,
+            generatedColumn: FIRST_COLUMN,
+            source: null,
+            name: null,
+            originalLine: null,
+            originalColumn: null,
+          };
+        }
+        first = false;
+        yield {
+          ...mapping,
+          generatedLine: add(mapping.generatedLine, generatedOffset.lines),
+          generatedColumn: add(
+            mapping.generatedColumn,
+            generatedOffset.columns,
+          ),
+        };
+      }
+    }
+  }
+
+  _consumerForPosition(
+    generatedPosition: GeneratedPositionLookup,
+  ): ?[GeneratedOffset, IConsumer] {
+    const {line, column} = generatedPosition;
+    if (line == null || column == null) {
+      return null;
+    }
+    const index = greatestLowerBound(
+      this._consumers,
+      generatedPosition,
+      (position, [offset]) => {
+        const line0 = sub1(line);
+        const column0 = column;
+        if (line0 === offset.lines) {
+          return get0(sub(column0, offset.columns));
+        }
+        return get0(sub(line0, offset.lines));
+      },
+    );
+    return index != null ? this._consumers[index] : null;
+  }
+}
+
+module.exports = SectionsConsumer;

package/src/Consumer/constants.js

@@ -0,0 +1,47 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *  strict-local
+ * @format
+ */
+"use strict";
+
+const _require = require("ob1"),
+  add0 = _require.add0,
+  add1 = _require.add1;
+
+const FIRST_COLUMN = add0(0);
+const FIRST_LINE = add1(0);
+const GENERATED_ORDER = "GENERATED_ORDER";
+const ORIGINAL_ORDER = "ORIGINAL_ORDER";
+const GREATEST_LOWER_BOUND = "GREATEST_LOWER_BOUND";
+const LEAST_UPPER_BOUND = "LEAST_UPPER_BOUND";
+const EMPTY_POSITION = Object.freeze({
+  source: null,
+  name: null,
+  line: null,
+  column: null
+});
+
+function iterationOrderToString(x) {
+  return x;
+}
+
+function lookupBiasToString(x) {
+  return x;
+}
+
+module.exports = {
+  FIRST_COLUMN,
+  FIRST_LINE,
+  GENERATED_ORDER,
+  ORIGINAL_ORDER,
+  GREATEST_LOWER_BOUND,
+  LEAST_UPPER_BOUND,
+  EMPTY_POSITION,
+  iterationOrderToString,
+  lookupBiasToString
+};

package/src/Consumer/constants.js.flow

@@ -0,0 +1,50 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+const {add0, add1} = require('ob1');
+const FIRST_COLUMN = add0(0);
+const FIRST_LINE = add1(0);
+
+export opaque type IterationOrder = 'GENERATED_ORDER' | 'ORIGINAL_ORDER';
+const GENERATED_ORDER: IterationOrder = 'GENERATED_ORDER';
+const ORIGINAL_ORDER: IterationOrder = 'ORIGINAL_ORDER';
+
+export opaque type LookupBias = 'GREATEST_LOWER_BOUND' | 'LEAST_UPPER_BOUND';
+const GREATEST_LOWER_BOUND: LookupBias = 'GREATEST_LOWER_BOUND';
+const LEAST_UPPER_BOUND: LookupBias = 'LEAST_UPPER_BOUND';
+
+const EMPTY_POSITION = Object.freeze({
+  source: null,
+  name: null,
+  line: null,
+  column: null,
+});
+
+function iterationOrderToString(x: IterationOrder): string {
+  return x;
+}
+
+function lookupBiasToString(x: LookupBias): string {
+  return x;
+}
+
+module.exports = {
+  FIRST_COLUMN,
+  FIRST_LINE,
+  GENERATED_ORDER,
+  ORIGINAL_ORDER,
+  GREATEST_LOWER_BOUND,
+  LEAST_UPPER_BOUND,
+  EMPTY_POSITION,
+  iterationOrderToString,
+  lookupBiasToString,
+};

package/src/Consumer/createConsumer.js

@@ -0,0 +1,31 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *  strict-local
+ * @format
+ */
+"use strict";
+
+const invariant = require("invariant");
+
+function createConsumer(sourceMap) {
+  invariant(
+    sourceMap.version === "3" || sourceMap.version === 3,
+    `Unrecognized source map format version: ${sourceMap.version}`
+  );
+
+  const MappingsConsumer = require("./MappingsConsumer");
+
+  const SectionsConsumer = require("./SectionsConsumer"); // eslint-disable-next-line lint/strictly-null
+
+  if (sourceMap.mappings === undefined) {
+    return new SectionsConsumer(sourceMap);
+  }
+
+  return new MappingsConsumer(sourceMap);
+}
+
+module.exports = createConsumer;

package/src/Consumer/createConsumer.js.flow

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+const invariant = require('invariant');
+
+import type {MixedSourceMap} from '../source-map';
+import type {IConsumer} from './types.flow';
+
+function createConsumer(sourceMap: MixedSourceMap): IConsumer {
+  invariant(
+    (sourceMap.version: mixed) === '3' || sourceMap.version === 3,
+    `Unrecognized source map format version: ${sourceMap.version}`,
+  );
+  const MappingsConsumer = require('./MappingsConsumer');
+  const SectionsConsumer = require('./SectionsConsumer');
+
+  // eslint-disable-next-line lint/strictly-null
+  if (sourceMap.mappings === undefined) {
+    return new SectionsConsumer(sourceMap);
+  }
+  return new MappingsConsumer(sourceMap);
+}
+
+module.exports = createConsumer;

package/src/Consumer/index.js

@@ -0,0 +1,14 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ *  strict-local
+ * @format
+ */
+"use strict"; // Implements an API-compatible subset of source-map's `SourceMapConsumer`.
+
+const DelegatingConsumer = require("./DelegatingConsumer");
+
+module.exports = DelegatingConsumer;

package/src/Consumer/index.js.flow

@@ -0,0 +1,16 @@
+/**
+ * Copyright (c) Facebook, Inc. and its affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict-local
+ * @format
+ */
+
+'use strict';
+
+// Implements an API-compatible subset of source-map's `SourceMapConsumer`.
+const DelegatingConsumer = require('./DelegatingConsumer');
+
+module.exports = DelegatingConsumer;