@difizen/libro-common 0.3.3 → 1.0.0

package/es/common/objects.js

@@ -0,0 +1,232 @@
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+/*---------------------------------------------------------------------------------------------
+ *  Copyright (c) Microsoft Corporation. All rights reserved.
+ *  Licensed under the MIT License. See License.txt in the project root for license information.
+ *--------------------------------------------------------------------------------------------*/
+
+import { isObject, isUndefinedOrNull, isArray } from "./valueTypes";
+export function deepClone(obj) {
+  if (!obj || _typeof(obj) !== 'object') {
+    return obj;
+  }
+  if (obj instanceof RegExp) {
+    // See https://github.com/microsoft/TypeScript/issues/10990
+    return obj;
+  }
+  var result = Array.isArray(obj) ? [] : {};
+  Object.keys(obj).forEach(function (key) {
+    if (obj[key] && _typeof(obj[key]) === 'object') {
+      result[key] = deepClone(obj[key]);
+    } else {
+      result[key] = obj[key];
+    }
+  });
+  return result;
+}
+export function deepFreeze(obj) {
+  if (!obj || _typeof(obj) !== 'object') {
+    return obj;
+  }
+  var stack = [obj];
+  while (stack.length > 0) {
+    var _obj = stack.shift();
+    Object.freeze(_obj);
+    for (var key in _obj) {
+      // eslint-disable-next-line @typescript-eslint/no-use-before-define
+      if (_hasOwnProperty.call(_obj, key)) {
+        var prop = _obj[key];
+        if (_typeof(prop) === 'object' && !Object.isFrozen(prop)) {
+          stack.push(prop);
+        }
+      }
+    }
+  }
+  return obj;
+}
+var _hasOwnProperty = Object.prototype.hasOwnProperty;
+export function cloneAndChange(obj, changer) {
+  return _cloneAndChange(obj, changer, new Set());
+}
+function _cloneAndChange(obj, changer, seen) {
+  if (isUndefinedOrNull(obj)) {
+    return obj;
+  }
+  var changed = changer(obj);
+  if (typeof changed !== 'undefined') {
+    return changed;
+  }
+  if (isArray(obj)) {
+    var r1 = [];
+    var _iterator = _createForOfIteratorHelper(obj),
+      _step;
+    try {
+      for (_iterator.s(); !(_step = _iterator.n()).done;) {
+        var e = _step.value;
+        r1.push(_cloneAndChange(e, changer, seen));
+      }
+    } catch (err) {
+      _iterator.e(err);
+    } finally {
+      _iterator.f();
+    }
+    return r1;
+  }
+  if (isObject(obj)) {
+    if (seen.has(obj)) {
+      throw new Error('Cannot clone recursive data-structure');
+    }
+    seen.add(obj);
+    var r2 = {};
+    for (var i2 in obj) {
+      if (_hasOwnProperty.call(obj, i2)) {
+        r2[i2] = _cloneAndChange(obj[i2], changer, seen);
+      }
+    }
+    seen.delete(obj);
+    return r2;
+  }
+  return obj;
+}
+
+/**
+ * Copies all properties of source into destination. The optional parameter "overwrite" allows to control
+ * if existing properties on the destination should be overwritten or not. Defaults to true (overwrite).
+ */
+export function mixin(destination, source) {
+  var overwrite = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : true;
+  if (!isObject(destination)) {
+    return source;
+  }
+  if (isObject(source)) {
+    Object.keys(source).forEach(function (key) {
+      if (key in destination) {
+        if (overwrite) {
+          if (isObject(destination[key]) && isObject(source[key])) {
+            mixin(destination[key], source[key], overwrite);
+          } else {
+            destination[key] = source[key];
+          }
+        }
+      } else {
+        destination[key] = source[key];
+      }
+    });
+  }
+  return destination;
+}
+export function objectEquals(one, other) {
+  if (one === other) {
+    return true;
+  }
+  if (one === null || one === undefined || other === null || other === undefined) {
+    return false;
+  }
+  if (_typeof(one) !== _typeof(other)) {
+    return false;
+  }
+  if (_typeof(one) !== 'object') {
+    return false;
+  }
+  if (Array.isArray(one) !== Array.isArray(other)) {
+    return false;
+  }
+  var i;
+  var key;
+  if (Array.isArray(one)) {
+    if (one.length !== other.length) {
+      return false;
+    }
+    for (i = 0; i < one.length; i++) {
+      if (!objectEquals(one[i], other[i])) {
+        return false;
+      }
+    }
+  } else {
+    var oneKeys = [];
+    for (key in one) {
+      oneKeys.push(key);
+    }
+    oneKeys.sort();
+    var otherKeys = [];
+    for (key in other) {
+      otherKeys.push(key);
+    }
+    otherKeys.sort();
+    if (!objectEquals(oneKeys, otherKeys)) {
+      return false;
+    }
+    for (i = 0; i < oneKeys.length; i++) {
+      if (!objectEquals(one[oneKeys[i]], other[oneKeys[i]])) {
+        return false;
+      }
+    }
+  }
+  return true;
+}
+
+/**
+ * Calls `JSON.Stringify` with a replacer to break apart any circular references.
+ * This prevents `JSON`.stringify` from throwing the exception
+ *  "Uncaught TypeError: Converting circular structure to JSON"
+ */
+export function safeStringify(obj) {
+  var seen = new Set();
+  return JSON.stringify(obj, function (_key, value) {
+    if (isObject(value) || Array.isArray(value)) {
+      if (seen.has(value)) {
+        return '[Circular]';
+      }
+      seen.add(value);
+    }
+    return value;
+  });
+}
+export function getOrDefault(obj, fn, defaultValue) {
+  var result = fn(obj);
+  return typeof result === 'undefined' ? defaultValue : result;
+}
+/**
+ * Returns an object that has keys for each value that is different in the base object. Keys
+ * that do not exist in the target but in the base object are not considered.
+ *
+ * Note: This is not a deep-diffing method, so the values are strictly taken into the resulting
+ * object if they differ.
+ *
+ * @param base the object to diff against
+ * @param obj the object to use for diffing
+ */
+export function distinct(base, target) {
+  var result = Object.create(null);
+  if (!base || !target) {
+    return result;
+  }
+  var targetKeys = Object.keys(target);
+  targetKeys.forEach(function (k) {
+    var baseValue = base[k];
+    var targetValue = target[k];
+    if (!objectEquals(baseValue, targetValue)) {
+      result[k] = targetValue;
+    }
+  });
+  return result;
+}
+export function getCaseInsensitive(target, key) {
+  var lowercaseKey = key.toLowerCase();
+  var equivalentKey = Object.keys(target).find(function (k) {
+    return k.toLowerCase() === lowercaseKey;
+  });
+  return equivalentKey ? target[equivalentKey] : target[key];
+}
+export function notEmpty(arg) {
+  return arg !== undefined && arg !== null;
+}
+
+/**
+ * `true` if the argument is an empty object. Otherwise, `false`.
+ */
+export function isEmpty(arg) {
+  return Object.keys(arg).length === 0 && arg.constructor === Object;
+}

package/es/common/observable-disposable.d.ts

@@ -0,0 +1,12 @@
+import type { Disposable } from './disposable';
+import type { Event } from './event';
+/**
+ * A disposable object with an observable `disposed` signal.
+ */
+export interface ObservableDisposable extends Disposable {
+    /**
+     * A signal emitted when the object is disposed.
+     */
+    readonly onDisposed: Event<void>;
+}
+//# sourceMappingURL=observable-disposable.d.ts.map

package/es/common/observable-disposable.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"observable-disposable.d.ts","sourceRoot":"","sources":["../../src/common/observable-disposable.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAC;AAErC;;GAEG;AACH,MAAM,WAAW,oBAAqB,SAAQ,UAAU;IACtD;;OAEG;IACH,QAAQ,CAAC,UAAU,EAAE,KAAK,CAAC,IAAI,CAAC,CAAC;CAClC"}

package/es/common/observable-disposable.js

@@ -0,0 +1 @@
+export {};

package/es/common/path.d.ts

@@ -0,0 +1,59 @@
+export declare class Path {
+    static separator: string;
+    static isDrive(segment: string): boolean;
+    /**
+     * vscode-uri always normalizes drive letters to lower case:
+     * https://github.com/Microsoft/vscode-uri/blob/b1d3221579f97f28a839b6f996d76fc45e9964d8/src/index.ts#L1025
+     */
+    static normalizeDrive(path: string): string;
+    /**
+     * Normalize path separator to use Path.separator
+     * @param Path candidate to normalize
+     * @returns Normalized string path
+     */
+    static normalizePathSeparator(path: string): string;
+    static normalizePath(path: string): string;
+    readonly isAbsolute: boolean;
+    get isRelative(): boolean;
+    readonly isRoot: boolean;
+    readonly isDrive: boolean;
+    readonly root: Path | undefined;
+    readonly base: string;
+    readonly name: string;
+    readonly ext: string;
+    private _dir;
+    private readonly raw;
+    /**
+     * The raw should be normalized, meaning that only '/' is allowed as a path separator.
+     */
+    constructor(raw: string);
+    /**
+     * Returns the parent directory if it exists (`hasDir === true`) or `this` otherwise.
+     */
+    get dir(): Path;
+    /**
+     * Returns `true` if this has a parent directory, `false` otherwise.
+     *
+     * _This implementation returns `true` if and only if this is not the root dir and
+     * there is a path separator in the raw path._
+     */
+    get hasDir(): boolean;
+    protected doGetDir(): Path;
+    includes(path: Path): boolean;
+    toString(): string;
+    static toRoot(path: Path): Path | undefined;
+    static join(path: Path, ...paths: string[]): Path;
+    /**
+     *
+     * @param paths portions of a path
+     * @returns a new Path if an absolute path can be computed from the segments passed in + this.raw
+     * If no absolute path can be computed, returns undefined.
+     *
+     * Processes the path segments passed in from right to left (reverse order) concatenating until an
+     * absolute path is found.
+     */
+    static resolve(path: Path, ...paths: string[]): Path | undefined;
+    static relative(base: Path, path: Path): Path | undefined;
+    static normalize(path: Path): Path;
+}
+//# sourceMappingURL=path.d.ts.map

package/es/common/path.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"path.d.ts","sourceRoot":"","sources":["../../src/common/path.ts"],"names":[],"mappings":"AAAA,qBAAa,IAAI;IACf,MAAM,CAAC,SAAS,SAAO;IAEvB,MAAM,CAAC,OAAO,CAAC,OAAO,EAAE,MAAM,GAAG,OAAO;IAIxC;;;OAGG;IACH,MAAM,CAAC,cAAc,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAmB3C;;;;OAIG;IACH,MAAM,CAAC,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAInD,MAAM,CAAC,aAAa,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM;IAI1C,QAAQ,CAAC,UAAU,EAAE,OAAO,CAAC;IAE7B,IAAI,UAAU,IAAI,OAAO,CAExB;IAED,QAAQ,CAAC,MAAM,EAAE,OAAO,CAAC;IACzB,QAAQ,CAAC,OAAO,EAAE,OAAO,CAAC;IAC1B,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,SAAS,CAAC;IAChC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IAErB,OAAO,CAAC,IAAI,CAAmB;IAC/B,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAS;IAE7B;;OAEG;gBACS,GAAG,EAAE,MAAM;IAcvB;;OAEG;IACH,IAAI,GAAG,IAAI,IAAI,CAKd;IAED;;;;;OAKG;IACH,IAAI,MAAM,IAAI,OAAO,CAEpB;IAED,SAAS,CAAC,QAAQ,IAAI,IAAI;IAc1B,QAAQ,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO;IAI7B,QAAQ,IAAI,MAAM;IAIlB,MAAM,CAAC,MAAM,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS;IAwB3C,MAAM,CAAC,IAAI,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI;IAWjD;;;;;;;;OAQG;IACH,MAAM,CAAC,OAAO,CAAC,IAAI,EAAE,IAAI,EAAE,GAAG,KAAK,EAAE,MAAM,EAAE,GAAG,IAAI,GAAG,SAAS;IAgBhE,MAAM,CAAC,QAAQ,CAAC,IAAI,EAAE,IAAI,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,SAAS;IAkBzD,MAAM,CAAC,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,IAAI;CA6BnC"}

package/es/common/path.js

@@ -0,0 +1,258 @@
+function _typeof(o) { "@babel/helpers - typeof"; return _typeof = "function" == typeof Symbol && "symbol" == typeof Symbol.iterator ? function (o) { return typeof o; } : function (o) { return o && "function" == typeof Symbol && o.constructor === Symbol && o !== Symbol.prototype ? "symbol" : typeof o; }, _typeof(o); }
+function _createForOfIteratorHelper(o, allowArrayLike) { var it = typeof Symbol !== "undefined" && o[Symbol.iterator] || o["@@iterator"]; if (!it) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === "number") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError("Invalid attempt to iterate non-iterable instance.\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method."); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = it.call(o); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it.return != null) it.return(); } finally { if (didErr) throw err; } } }; }
+function _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === "string") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === "Object" && o.constructor) n = o.constructor.name; if (n === "Map" || n === "Set") return Array.from(o); if (n === "Arguments" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }
+function _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) arr2[i] = arr[i]; return arr2; }
+function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, _toPropertyKey(descriptor.key), descriptor); } }
+function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+function _toPropertyKey(t) { var i = _toPrimitive(t, "string"); return "symbol" == _typeof(i) ? i : String(i); }
+function _toPrimitive(t, r) { if ("object" != _typeof(t) || !t) return t; var e = t[Symbol.toPrimitive]; if (void 0 !== e) { var i = e.call(t, r || "default"); if ("object" != _typeof(i)) return i; throw new TypeError("@@toPrimitive must return a primitive value."); } return ("string" === r ? String : Number)(t); }
+export var Path = /*#__PURE__*/function () {
+  /**
+   * The raw should be normalized, meaning that only '/' is allowed as a path separator.
+   */
+  function Path(raw) {
+    _classCallCheck(this, Path);
+    this.raw = Path.normalizePath(raw);
+    var lastIndex = this.raw.lastIndexOf(Path.separator);
+    this.isAbsolute = this.raw.indexOf(Path.separator) === 0;
+    this.base = lastIndex === -1 ? this.raw : this.raw.substring(lastIndex + 1);
+    this.isDrive = Path.isDrive(this.base);
+    this.isRoot = this.isAbsolute && lastIndex === 0 && (!this.base || this.isDrive);
+    this.root = Path.toRoot(this);
+    var extIndex = this.base.lastIndexOf('.');
+    this.name = extIndex === -1 ? this.base : this.base.substring(0, extIndex);
+    this.ext = extIndex === -1 ? '' : this.base.substring(extIndex);
+  }
+
+  /**
+   * Returns the parent directory if it exists (`hasDir === true`) or `this` otherwise.
+   */
+  _createClass(Path, [{
+    key: "isRelative",
+    get: function get() {
+      return !this.isAbsolute;
+    }
+  }, {
+    key: "dir",
+    get: function get() {
+      if (this._dir === undefined) {
+        this._dir = this.doGetDir();
+      }
+      return this._dir;
+    }
+
+    /**
+     * Returns `true` if this has a parent directory, `false` otherwise.
+     *
+     * _This implementation returns `true` if and only if this is not the root dir and
+     * there is a path separator in the raw path._
+     */
+  }, {
+    key: "hasDir",
+    get: function get() {
+      return !this.isRoot && this.raw.lastIndexOf(Path.separator) !== -1;
+    }
+  }, {
+    key: "doGetDir",
+    value: function doGetDir() {
+      if (!this.hasDir) {
+        return this;
+      }
+      var lastIndex = this.raw.lastIndexOf(Path.separator);
+      if (this.isAbsolute) {
+        var firstIndex = this.raw.indexOf(Path.separator);
+        if (firstIndex === lastIndex) {
+          return new Path(this.raw.substr(0, firstIndex + 1));
+        }
+      }
+      return new Path(this.raw.substr(0, lastIndex));
+    }
+  }, {
+    key: "includes",
+    value: function includes(path) {
+      return !!Path.relative(this, path);
+    }
+  }, {
+    key: "toString",
+    value: function toString() {
+      return this.raw;
+    }
+  }], [{
+    key: "isDrive",
+    value: function isDrive(segment) {
+      return segment.endsWith(':');
+    }
+
+    /**
+     * vscode-uri always normalizes drive letters to lower case:
+     * https://github.com/Microsoft/vscode-uri/blob/b1d3221579f97f28a839b6f996d76fc45e9964d8/src/index.ts#L1025
+     */
+  }, {
+    key: "normalizeDrive",
+    value: function normalizeDrive(path) {
+      if (path.length > 3 && path[0] === '/' && path[2] === ':') {
+        var code = path.charCodeAt(1);
+        if (code >= 65 && code <= 90) {
+          path = "/".concat(path[1].toLowerCase(), ":").concat(path.substring(3));
+        }
+        return path;
+      }
+      if (path.length > 2 && path[1] === ':') {
+        var _code = path.charCodeAt(0);
+        if (_code >= 65 && _code <= 90) {
+          path = "".concat(path[0].toLowerCase(), ":").concat(path.substring(2));
+        }
+        if (path[0] !== '/') {
+          path = "/".concat(path);
+        }
+      }
+      return path;
+    }
+    /**
+     * Normalize path separator to use Path.separator
+     * @param Path candidate to normalize
+     * @returns Normalized string path
+     */
+  }, {
+    key: "normalizePathSeparator",
+    value: function normalizePathSeparator(path) {
+      return path.split(/[\\]/).join(Path.separator);
+    }
+  }, {
+    key: "normalizePath",
+    value: function normalizePath(path) {
+      return Path.normalizeDrive(Path.normalizePathSeparator(path));
+    }
+  }, {
+    key: "toRoot",
+    value: function toRoot(path) {
+      // '/' -> '/'
+      // '/c:' -> '/c:'
+      if (path.isRoot) {
+        return path;
+      }
+
+      // 'foo/bar' -> `undefined`
+      if (path.isRelative) {
+        return undefined;
+      }
+      var index = path.raw.indexOf(Path.separator, Path.separator.length);
+      if (index === -1) {
+        // '/foo/bar' -> '/'
+        return new Path(Path.separator);
+      }
+
+      // '/c:/foo/bar' -> '/c:'
+      // '/foo/bar' -> '/'
+      return new Path(path.raw.substring(0, index)).root;
+    }
+  }, {
+    key: "join",
+    value: function join(path) {
+      for (var _len = arguments.length, paths = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {
+        paths[_key - 1] = arguments[_key];
+      }
+      var relativePath = paths.filter(function (s) {
+        return !!s;
+      }).join(Path.separator);
+      if (!relativePath) {
+        return path;
+      }
+      if (path.raw.endsWith(Path.separator)) {
+        return new Path(path.raw + relativePath);
+      }
+      return new Path(path.raw + Path.separator + relativePath);
+    }
+
+    /**
+     *
+     * @param paths portions of a path
+     * @returns a new Path if an absolute path can be computed from the segments passed in + this.raw
+     * If no absolute path can be computed, returns undefined.
+     *
+     * Processes the path segments passed in from right to left (reverse order) concatenating until an
+     * absolute path is found.
+     */
+  }, {
+    key: "resolve",
+    value: function resolve(path) {
+      for (var _len2 = arguments.length, paths = new Array(_len2 > 1 ? _len2 - 1 : 0), _key2 = 1; _key2 < _len2; _key2++) {
+        paths[_key2 - 1] = arguments[_key2];
+      }
+      var segments = paths.slice().reverse(); // Don't mutate the caller's array.
+      segments.push(path.raw);
+      var result = new Path('');
+      var _iterator = _createForOfIteratorHelper(segments),
+        _step;
+      try {
+        for (_iterator.s(); !(_step = _iterator.n()).done;) {
+          var segment = _step.value;
+          if (segment) {
+            var next = Path.join(new Path(segment), result.raw);
+            if (next.isAbsolute) {
+              return Path.normalize(next);
+            }
+            result = next;
+          }
+        }
+      } catch (err) {
+        _iterator.e(err);
+      } finally {
+        _iterator.f();
+      }
+      return undefined;
+    }
+  }, {
+    key: "relative",
+    value: function relative(base, path) {
+      if (base.raw === path.raw) {
+        return new Path('');
+      }
+      if (!base.raw || !path.raw) {
+        return undefined;
+      }
+      var raw = base.base ? base.raw + Path.separator : base.raw;
+      if (!path.raw.startsWith(raw)) {
+        return undefined;
+      }
+      var relativePath = path.raw.substr(raw.length);
+      return new Path(relativePath);
+    }
+
+    /*
+     * return a normalized Path, resolving '..' and '.' segments
+     */
+  }, {
+    key: "normalize",
+    value: function normalize(path) {
+      var trailingSlash = path.raw.endsWith('/');
+      var pathArray = path.toString().split('/');
+      var resultArray = [];
+      pathArray.forEach(function (value) {
+        if (!value || value === '.') {
+          return;
+        }
+        if (value === '..') {
+          if (resultArray.length && resultArray[resultArray.length - 1] !== '..') {
+            resultArray.pop();
+          } else if (path.isRelative) {
+            resultArray.push('..');
+          }
+        } else {
+          resultArray.push(value);
+        }
+      });
+      if (resultArray.length === 0) {
+        if (path.isRoot) {
+          return new Path('/');
+        } else {
+          return new Path('.');
+        }
+      }
+      return new Path((path.isAbsolute ? '/' : '') + resultArray.join('/') + (trailingSlash ? '/' : ''));
+    }
+  }]);
+  return Path;
+}();
+Path.separator = '/';

package/es/common/platform.d.ts

@@ -0,0 +1,72 @@
+export type IProcessEnvironment = Record<string, string>;
+export interface INodeProcess {
+    platform: 'win32' | 'linux' | 'darwin';
+    env: IProcessEnvironment;
+    nextTick: () => void;
+    versions?: {
+        electron?: string;
+    };
+    sandboxed?: boolean;
+    type?: string;
+    cwd: () => string;
+}
+export declare const isElectronSandboxed: boolean | undefined;
+export declare const browserCodeLoadingCacheStrategy: 'none' | 'code' | 'bypassHeatCheck' | 'bypassHeatCheckAndEagerCompile' | undefined;
+export declare const isPreferringBrowserCodeLoad: boolean;
+export declare enum Platform {
+    Web = 0,
+    Mac = 1,
+    Linux = 2,
+    Windows = 3
+}
+export declare function PlatformToString(platform: Platform): "Windows" | "Linux" | "Web" | "Mac";
+export declare const isWindows: boolean;
+export declare const isMacintosh: boolean;
+export declare const isOSX: boolean;
+export declare const isLinux: boolean;
+export declare const isLinuxSnap: boolean;
+export declare const isNative: boolean;
+export declare const isWeb: boolean;
+export declare const isIOS: boolean;
+export declare const platform: Platform;
+export declare const userAgent: string | undefined;
+export declare const isIE: boolean;
+export declare const isEdge: boolean;
+export declare const isEdgeOrIE: boolean;
+export declare const isOpera: boolean;
+export declare const isFirefox: boolean;
+export declare const isWebKit: boolean;
+export declare const isChrome: boolean;
+export declare const isSafari: boolean;
+export declare const isIPad: boolean;
+/**
+ * The language used for the user interface. The format of
+ * the string is all lower case (e.g. zh-tw for Traditional
+ * Chinese)
+ */
+export declare const language: string;
+export declare namespace Language {
+    function value(): string;
+    function isDefaultVariant(): boolean;
+    function isDefault(): boolean;
+}
+/**
+ * The OS locale or the locale specified by --locale. The format of
+ * the string is all lower case (e.g. zh-tw for Traditional
+ * Chinese). The UI is not necessarily shown in the provided locale.
+ */
+export declare const locale: string | undefined;
+/**
+ * The translatios that are available through language packs.
+ */
+export declare const translationsConfigFile: string | undefined;
+export declare const globals: any;
+export declare enum OperatingSystem {
+    Windows = 1,
+    Macintosh = 2,
+    Linux = 3
+}
+export declare const OS: OperatingSystem;
+export declare function isLittleEndian(): boolean;
+export declare const isBasicWasmSupported: boolean;
+//# sourceMappingURL=platform.d.ts.map

package/es/common/platform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"platform.d.ts","sourceRoot":"","sources":["../../src/common/platform.ts"],"names":[],"mappings":"AAkCA,MAAM,MAAM,mBAAmB,GAAG,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAEzD,MAAM,WAAW,YAAY;IAC3B,QAAQ,EAAE,OAAO,GAAG,OAAO,GAAG,QAAQ,CAAC;IACvC,GAAG,EAAE,mBAAmB,CAAC;IACzB,QAAQ,EAAE,MAAM,IAAI,CAAC;IACrB,QAAQ,CAAC,EAAE;QACT,QAAQ,CAAC,EAAE,MAAM,CAAC;KACnB,CAAC;IACF,SAAS,CAAC,EAAE,OAAO,CAAC;IACpB,IAAI,CAAC,EAAE,MAAM,CAAC;IACd,GAAG,EAAE,MAAM,MAAM,CAAC;CACnB;AA2BD,eAAO,MAAM,mBAAmB,qBAA+C,CAAC;AAChF,eAAO,MAAM,+BAA+B,EACxC,MAAM,GACN,MAAM,GACN,iBAAiB,GACjB,gCAAgC,GAChC,SAsBA,CAAC;AACL,eAAO,MAAM,2BAA2B,SACa,CAAC;AA2DtD,oBAAY,QAAQ;IAClB,GAAG,IAAA;IACH,GAAG,IAAA;IACH,KAAK,IAAA;IACL,OAAO,IAAA;CACR;AACD,wBAAgB,gBAAgB,CAAC,QAAQ,EAAE,QAAQ,uCAWlD;AAWD,eAAO,MAAM,SAAS,SAAa,CAAC;AACpC,eAAO,MAAM,WAAW,SAAe,CAAC;AACxC,eAAO,MAAM,KAAK,SAAe,CAAC;AAClC,eAAO,MAAM,OAAO,SAAW,CAAC;AAChC,eAAO,MAAM,WAAW,SAAe,CAAC;AACxC,eAAO,MAAM,QAAQ,SAAY,CAAC;AAClC,eAAO,MAAM,KAAK,SAAS,CAAC;AAC5B,eAAO,MAAM,KAAK,SAAS,CAAC;AAC5B,eAAO,MAAM,QAAQ,UAAY,CAAC;AAClC,eAAO,MAAM,SAAS,oBAAa,CAAC;AAEpC,eAAO,MAAM,IAAI,SAAQ,CAAC;AAC1B,eAAO,MAAM,MAAM,SAAU,CAAC;AAC9B,eAAO,MAAM,UAAU,SAAiB,CAAC;AACzC,eAAO,MAAM,OAAO,SAAW,CAAC;AAChC,eAAO,MAAM,SAAS,SAAa,CAAC;AACpC,eAAO,MAAM,QAAQ,SAAY,CAAC;AAClC,eAAO,MAAM,QAAQ,SAAY,CAAC;AAClC,eAAO,MAAM,QAAQ,SAAY,CAAC;AAClC,eAAO,MAAM,MAAM,SAAU,CAAC;AAE9B;;;;GAIG;AACH,eAAO,MAAM,QAAQ,QAAY,CAAC;AAElC,yBAAiB,QAAQ,CAAC;IACxB,SAAgB,KAAK,IAAI,MAAM,CAE9B;IAED,SAAgB,gBAAgB,IAAI,OAAO,CAQ1C;IAED,SAAgB,SAAS,IAAI,OAAO,CAEnC;CACF;AAED;;;;GAIG;AACH,eAAO,MAAM,MAAM,oBAAU,CAAC;AAE9B;;GAEG;AACH,eAAO,MAAM,sBAAsB,oBAA0B,CAAC;AAE9D,eAAO,MAAM,OAAO,EAAE,GAAc,CAAC;AAErC,oBAAY,eAAe;IACzB,OAAO,IAAI;IACX,SAAS,IAAI;IACb,KAAK,IAAI;CACV;AACD,eAAO,MAAM,EAAE,iBAKc,CAAC;AAI9B,wBAAgB,cAAc,IAAI,OAAO,CAUxC;AAGD,eAAO,MAAM,oBAAoB,SAC4B,CAAC"}