@hashgraphonline/standards-sdk 0.0.88 → 0.0.90

package/dist/es/standards-sdk.es74.js

@@ -1,796 +1,412 @@
-var __defProp = Object.defineProperty;
-var __typeError = (msg) => {
-  throw TypeError(msg);
-};
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
-var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
-var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
-var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
-var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
-var _options;
-import { assertPrivate } from "./standards-sdk.es67.js";
-import { defineProperties } from "./standards-sdk.es70.js";
-const _gaurd = {};
-function n(value, width) {
-  let signed = false;
-  if (width < 0) {
-    signed = true;
-    width *= -1;
-  }
-  return new Typed(_gaurd, `${signed ? "" : "u"}int${width}`, value, { signed, width });
-}
-function b(value, size) {
-  return new Typed(_gaurd, `bytes${size ? size : ""}`, value, { size });
-}
-const _typedSymbol = Symbol.for("_ethers_typed");
-const _Typed = class _Typed {
-  /**
-   *  @_ignore:
-   */
-  constructor(gaurd, type, value, options) {
-    /**
-     *  The type, as a Solidity-compatible type.
-     */
-    __publicField(this, "type");
-    /**
-     *  The actual value.
-     */
-    __publicField(this, "value");
-    __privateAdd(this, _options);
-    /**
-     *  @_ignore:
-     */
-    __publicField(this, "_typedSymbol");
-    if (options == null) {
-      options = null;
+import process$1 from "./standards-sdk.es78.js";
+var pathBrowserify;
+var hasRequiredPathBrowserify;
+function requirePathBrowserify() {
+  if (hasRequiredPathBrowserify) return pathBrowserify;
+  hasRequiredPathBrowserify = 1;
+  function assertPath(path) {
+    if (typeof path !== "string") {
+      throw new TypeError("Path must be a string. Received " + JSON.stringify(path));
     }
-    assertPrivate(_gaurd, gaurd, "Typed");
-    defineProperties(this, { _typedSymbol, type, value });
-    __privateSet(this, _options, options);
-    this.format();
-  }
-  /**
-   *  Format the type as a Human-Readable type.
-   */
-  format() {
-    if (this.type === "array") {
-      throw new Error("");
-    } else if (this.type === "dynamicArray") {
-      throw new Error("");
-    } else if (this.type === "tuple") {
-      return `tuple(${this.value.map((v) => v.format()).join(",")})`;
-    }
-    return this.type;
-  }
-  /**
-   *  The default value returned by this type.
-   */
-  defaultValue() {
-    return 0;
-  }
-  /**
-   *  The minimum value for numeric types.
-   */
-  minValue() {
-    return 0;
-  }
-  /**
-   *  The maximum value for numeric types.
-   */
-  maxValue() {
-    return 0;
   }
-  /**
-   *  Returns ``true`` and provides a type guard is this is a [[TypedBigInt]].
-   */
-  isBigInt() {
-    return !!this.type.match(/^u?int[0-9]+$/);
-  }
-  /**
-   *  Returns ``true`` and provides a type guard is this is a [[TypedData]].
-   */
-  isData() {
-    return this.type.startsWith("bytes");
-  }
-  /**
-   *  Returns ``true`` and provides a type guard is this is a [[TypedString]].
-   */
-  isString() {
-    return this.type === "string";
-  }
-  /**
-   *  Returns the tuple name, if this is a tuple. Throws otherwise.
-   */
-  get tupleName() {
-    if (this.type !== "tuple") {
-      throw TypeError("not a tuple");
+  function normalizeStringPosix(path, allowAboveRoot) {
+    var res = "";
+    var lastSegmentLength = 0;
+    var lastSlash = -1;
+    var dots = 0;
+    var code;
+    for (var i = 0; i <= path.length; ++i) {
+      if (i < path.length)
+        code = path.charCodeAt(i);
+      else if (code === 47)
+        break;
+      else
+        code = 47;
+      if (code === 47) {
+        if (lastSlash === i - 1 || dots === 1) ;
+        else if (lastSlash !== i - 1 && dots === 2) {
+          if (res.length < 2 || lastSegmentLength !== 2 || res.charCodeAt(res.length - 1) !== 46 || res.charCodeAt(res.length - 2) !== 46) {
+            if (res.length > 2) {
+              var lastSlashIndex = res.lastIndexOf("/");
+              if (lastSlashIndex !== res.length - 1) {
+                if (lastSlashIndex === -1) {
+                  res = "";
+                  lastSegmentLength = 0;
+                } else {
+                  res = res.slice(0, lastSlashIndex);
+                  lastSegmentLength = res.length - 1 - res.lastIndexOf("/");
+                }
+                lastSlash = i;
+                dots = 0;
+                continue;
+              }
+            } else if (res.length === 2 || res.length === 1) {
+              res = "";
+              lastSegmentLength = 0;
+              lastSlash = i;
+              dots = 0;
+              continue;
+            }
+          }
+          if (allowAboveRoot) {
+            if (res.length > 0)
+              res += "/..";
+            else
+              res = "..";
+            lastSegmentLength = 2;
+          }
+        } else {
+          if (res.length > 0)
+            res += "/" + path.slice(lastSlash + 1, i);
+          else
+            res = path.slice(lastSlash + 1, i);
+          lastSegmentLength = i - lastSlash - 1;
+        }
+        lastSlash = i;
+        dots = 0;
+      } else if (code === 46 && dots !== -1) {
+        ++dots;
+      } else {
+        dots = -1;
+      }
     }
-    return __privateGet(this, _options);
+    return res;
   }
-  // Returns the length of this type as an array
-  // - `null` indicates the length is unforced, it could be dynamic
-  // - `-1` indicates the length is dynamic
-  // - any other value indicates it is a static array and is its length
-  /**
-   *  Returns the length of the array type or ``-1`` if it is dynamic.
-   *
-   *  Throws if the type is not an array.
-   */
-  get arrayLength() {
-    if (this.type !== "array") {
-      throw TypeError("not an array");
-    }
-    if (__privateGet(this, _options) === true) {
-      return -1;
+  function _format(sep, pathObject) {
+    var dir = pathObject.dir || pathObject.root;
+    var base = pathObject.base || (pathObject.name || "") + (pathObject.ext || "");
+    if (!dir) {
+      return base;
     }
-    if (__privateGet(this, _options) === false) {
-      return this.value.length;
+    if (dir === pathObject.root) {
+      return dir + base;
     }
-    return null;
-  }
-  /**
-   *  Returns a new **Typed** of %%type%% with the %%value%%.
-   */
-  static from(type, value) {
-    return new _Typed(_gaurd, type, value);
-  }
-  /**
-   *  Return a new ``uint8`` type for %%v%%.
-   */
-  static uint8(v) {
-    return n(v, 8);
-  }
-  /**
-   *  Return a new ``uint16`` type for %%v%%.
-   */
-  static uint16(v) {
-    return n(v, 16);
-  }
-  /**
-   *  Return a new ``uint24`` type for %%v%%.
-   */
-  static uint24(v) {
-    return n(v, 24);
-  }
-  /**
-   *  Return a new ``uint32`` type for %%v%%.
-   */
-  static uint32(v) {
-    return n(v, 32);
-  }
-  /**
-   *  Return a new ``uint40`` type for %%v%%.
-   */
-  static uint40(v) {
-    return n(v, 40);
-  }
-  /**
-   *  Return a new ``uint48`` type for %%v%%.
-   */
-  static uint48(v) {
-    return n(v, 48);
-  }
-  /**
-   *  Return a new ``uint56`` type for %%v%%.
-   */
-  static uint56(v) {
-    return n(v, 56);
-  }
-  /**
-   *  Return a new ``uint64`` type for %%v%%.
-   */
-  static uint64(v) {
-    return n(v, 64);
-  }
-  /**
-   *  Return a new ``uint72`` type for %%v%%.
-   */
-  static uint72(v) {
-    return n(v, 72);
-  }
-  /**
-   *  Return a new ``uint80`` type for %%v%%.
-   */
-  static uint80(v) {
-    return n(v, 80);
-  }
-  /**
-   *  Return a new ``uint88`` type for %%v%%.
-   */
-  static uint88(v) {
-    return n(v, 88);
-  }
-  /**
-   *  Return a new ``uint96`` type for %%v%%.
-   */
-  static uint96(v) {
-    return n(v, 96);
-  }
-  /**
-   *  Return a new ``uint104`` type for %%v%%.
-   */
-  static uint104(v) {
-    return n(v, 104);
-  }
-  /**
-   *  Return a new ``uint112`` type for %%v%%.
-   */
-  static uint112(v) {
-    return n(v, 112);
-  }
-  /**
-   *  Return a new ``uint120`` type for %%v%%.
-   */
-  static uint120(v) {
-    return n(v, 120);
-  }
-  /**
-   *  Return a new ``uint128`` type for %%v%%.
-   */
-  static uint128(v) {
-    return n(v, 128);
-  }
-  /**
-   *  Return a new ``uint136`` type for %%v%%.
-   */
-  static uint136(v) {
-    return n(v, 136);
-  }
-  /**
-   *  Return a new ``uint144`` type for %%v%%.
-   */
-  static uint144(v) {
-    return n(v, 144);
-  }
-  /**
-   *  Return a new ``uint152`` type for %%v%%.
-   */
-  static uint152(v) {
-    return n(v, 152);
-  }
-  /**
-   *  Return a new ``uint160`` type for %%v%%.
-   */
-  static uint160(v) {
-    return n(v, 160);
-  }
-  /**
-   *  Return a new ``uint168`` type for %%v%%.
-   */
-  static uint168(v) {
-    return n(v, 168);
-  }
-  /**
-   *  Return a new ``uint176`` type for %%v%%.
-   */
-  static uint176(v) {
-    return n(v, 176);
-  }
-  /**
-   *  Return a new ``uint184`` type for %%v%%.
-   */
-  static uint184(v) {
-    return n(v, 184);
-  }
-  /**
-   *  Return a new ``uint192`` type for %%v%%.
-   */
-  static uint192(v) {
-    return n(v, 192);
-  }
-  /**
-   *  Return a new ``uint200`` type for %%v%%.
-   */
-  static uint200(v) {
-    return n(v, 200);
-  }
-  /**
-   *  Return a new ``uint208`` type for %%v%%.
-   */
-  static uint208(v) {
-    return n(v, 208);
-  }
-  /**
-   *  Return a new ``uint216`` type for %%v%%.
-   */
-  static uint216(v) {
-    return n(v, 216);
-  }
-  /**
-   *  Return a new ``uint224`` type for %%v%%.
-   */
-  static uint224(v) {
-    return n(v, 224);
-  }
-  /**
-   *  Return a new ``uint232`` type for %%v%%.
-   */
-  static uint232(v) {
-    return n(v, 232);
-  }
-  /**
-   *  Return a new ``uint240`` type for %%v%%.
-   */
-  static uint240(v) {
-    return n(v, 240);
-  }
-  /**
-   *  Return a new ``uint248`` type for %%v%%.
-   */
-  static uint248(v) {
-    return n(v, 248);
-  }
-  /**
-   *  Return a new ``uint256`` type for %%v%%.
-   */
-  static uint256(v) {
-    return n(v, 256);
-  }
-  /**
-   *  Return a new ``uint256`` type for %%v%%.
-   */
-  static uint(v) {
-    return n(v, 256);
-  }
-  /**
-   *  Return a new ``int8`` type for %%v%%.
-   */
-  static int8(v) {
-    return n(v, -8);
-  }
-  /**
-   *  Return a new ``int16`` type for %%v%%.
-   */
-  static int16(v) {
-    return n(v, -16);
-  }
-  /**
-   *  Return a new ``int24`` type for %%v%%.
-   */
-  static int24(v) {
-    return n(v, -24);
-  }
-  /**
-   *  Return a new ``int32`` type for %%v%%.
-   */
-  static int32(v) {
-    return n(v, -32);
-  }
-  /**
-   *  Return a new ``int40`` type for %%v%%.
-   */
-  static int40(v) {
-    return n(v, -40);
-  }
-  /**
-   *  Return a new ``int48`` type for %%v%%.
-   */
-  static int48(v) {
-    return n(v, -48);
-  }
-  /**
-   *  Return a new ``int56`` type for %%v%%.
-   */
-  static int56(v) {
-    return n(v, -56);
-  }
-  /**
-   *  Return a new ``int64`` type for %%v%%.
-   */
-  static int64(v) {
-    return n(v, -64);
-  }
-  /**
-   *  Return a new ``int72`` type for %%v%%.
-   */
-  static int72(v) {
-    return n(v, -72);
-  }
-  /**
-   *  Return a new ``int80`` type for %%v%%.
-   */
-  static int80(v) {
-    return n(v, -80);
-  }
-  /**
-   *  Return a new ``int88`` type for %%v%%.
-   */
-  static int88(v) {
-    return n(v, -88);
-  }
-  /**
-   *  Return a new ``int96`` type for %%v%%.
-   */
-  static int96(v) {
-    return n(v, -96);
-  }
-  /**
-   *  Return a new ``int104`` type for %%v%%.
-   */
-  static int104(v) {
-    return n(v, -104);
-  }
-  /**
-   *  Return a new ``int112`` type for %%v%%.
-   */
-  static int112(v) {
-    return n(v, -112);
-  }
-  /**
-   *  Return a new ``int120`` type for %%v%%.
-   */
-  static int120(v) {
-    return n(v, -120);
-  }
-  /**
-   *  Return a new ``int128`` type for %%v%%.
-   */
-  static int128(v) {
-    return n(v, -128);
-  }
-  /**
-   *  Return a new ``int136`` type for %%v%%.
-   */
-  static int136(v) {
-    return n(v, -136);
-  }
-  /**
-   *  Return a new ``int144`` type for %%v%%.
-   */
-  static int144(v) {
-    return n(v, -144);
-  }
-  /**
-   *  Return a new ``int52`` type for %%v%%.
-   */
-  static int152(v) {
-    return n(v, -152);
-  }
-  /**
-   *  Return a new ``int160`` type for %%v%%.
-   */
-  static int160(v) {
-    return n(v, -160);
-  }
-  /**
-   *  Return a new ``int168`` type for %%v%%.
-   */
-  static int168(v) {
-    return n(v, -168);
-  }
-  /**
-   *  Return a new ``int176`` type for %%v%%.
-   */
-  static int176(v) {
-    return n(v, -176);
-  }
-  /**
-   *  Return a new ``int184`` type for %%v%%.
-   */
-  static int184(v) {
-    return n(v, -184);
-  }
-  /**
-   *  Return a new ``int92`` type for %%v%%.
-   */
-  static int192(v) {
-    return n(v, -192);
-  }
-  /**
-   *  Return a new ``int200`` type for %%v%%.
-   */
-  static int200(v) {
-    return n(v, -200);
-  }
-  /**
-   *  Return a new ``int208`` type for %%v%%.
-   */
-  static int208(v) {
-    return n(v, -208);
-  }
-  /**
-   *  Return a new ``int216`` type for %%v%%.
-   */
-  static int216(v) {
-    return n(v, -216);
-  }
-  /**
-   *  Return a new ``int224`` type for %%v%%.
-   */
-  static int224(v) {
-    return n(v, -224);
-  }
-  /**
-   *  Return a new ``int232`` type for %%v%%.
-   */
-  static int232(v) {
-    return n(v, -232);
-  }
-  /**
-   *  Return a new ``int240`` type for %%v%%.
-   */
-  static int240(v) {
-    return n(v, -240);
-  }
-  /**
-   *  Return a new ``int248`` type for %%v%%.
-   */
-  static int248(v) {
-    return n(v, -248);
-  }
-  /**
-   *  Return a new ``int256`` type for %%v%%.
-   */
-  static int256(v) {
-    return n(v, -256);
-  }
-  /**
-   *  Return a new ``int256`` type for %%v%%.
-   */
-  static int(v) {
-    return n(v, -256);
-  }
-  /**
-   *  Return a new ``bytes1`` type for %%v%%.
-   */
-  static bytes1(v) {
-    return b(v, 1);
-  }
-  /**
-   *  Return a new ``bytes2`` type for %%v%%.
-   */
-  static bytes2(v) {
-    return b(v, 2);
-  }
-  /**
-   *  Return a new ``bytes3`` type for %%v%%.
-   */
-  static bytes3(v) {
-    return b(v, 3);
-  }
-  /**
-   *  Return a new ``bytes4`` type for %%v%%.
-   */
-  static bytes4(v) {
-    return b(v, 4);
-  }
-  /**
-   *  Return a new ``bytes5`` type for %%v%%.
-   */
-  static bytes5(v) {
-    return b(v, 5);
-  }
-  /**
-   *  Return a new ``bytes6`` type for %%v%%.
-   */
-  static bytes6(v) {
-    return b(v, 6);
-  }
-  /**
-   *  Return a new ``bytes7`` type for %%v%%.
-   */
-  static bytes7(v) {
-    return b(v, 7);
-  }
-  /**
-   *  Return a new ``bytes8`` type for %%v%%.
-   */
-  static bytes8(v) {
-    return b(v, 8);
-  }
-  /**
-   *  Return a new ``bytes9`` type for %%v%%.
-   */
-  static bytes9(v) {
-    return b(v, 9);
-  }
-  /**
-   *  Return a new ``bytes10`` type for %%v%%.
-   */
-  static bytes10(v) {
-    return b(v, 10);
-  }
-  /**
-   *  Return a new ``bytes11`` type for %%v%%.
-   */
-  static bytes11(v) {
-    return b(v, 11);
-  }
-  /**
-   *  Return a new ``bytes12`` type for %%v%%.
-   */
-  static bytes12(v) {
-    return b(v, 12);
-  }
-  /**
-   *  Return a new ``bytes13`` type for %%v%%.
-   */
-  static bytes13(v) {
-    return b(v, 13);
-  }
-  /**
-   *  Return a new ``bytes14`` type for %%v%%.
-   */
-  static bytes14(v) {
-    return b(v, 14);
-  }
-  /**
-   *  Return a new ``bytes15`` type for %%v%%.
-   */
-  static bytes15(v) {
-    return b(v, 15);
-  }
-  /**
-   *  Return a new ``bytes16`` type for %%v%%.
-   */
-  static bytes16(v) {
-    return b(v, 16);
-  }
-  /**
-   *  Return a new ``bytes17`` type for %%v%%.
-   */
-  static bytes17(v) {
-    return b(v, 17);
-  }
-  /**
-   *  Return a new ``bytes18`` type for %%v%%.
-   */
-  static bytes18(v) {
-    return b(v, 18);
-  }
-  /**
-   *  Return a new ``bytes19`` type for %%v%%.
-   */
-  static bytes19(v) {
-    return b(v, 19);
-  }
-  /**
-   *  Return a new ``bytes20`` type for %%v%%.
-   */
-  static bytes20(v) {
-    return b(v, 20);
-  }
-  /**
-   *  Return a new ``bytes21`` type for %%v%%.
-   */
-  static bytes21(v) {
-    return b(v, 21);
-  }
-  /**
-   *  Return a new ``bytes22`` type for %%v%%.
-   */
-  static bytes22(v) {
-    return b(v, 22);
-  }
-  /**
-   *  Return a new ``bytes23`` type for %%v%%.
-   */
-  static bytes23(v) {
-    return b(v, 23);
-  }
-  /**
-   *  Return a new ``bytes24`` type for %%v%%.
-   */
-  static bytes24(v) {
-    return b(v, 24);
-  }
-  /**
-   *  Return a new ``bytes25`` type for %%v%%.
-   */
-  static bytes25(v) {
-    return b(v, 25);
-  }
-  /**
-   *  Return a new ``bytes26`` type for %%v%%.
-   */
-  static bytes26(v) {
-    return b(v, 26);
-  }
-  /**
-   *  Return a new ``bytes27`` type for %%v%%.
-   */
-  static bytes27(v) {
-    return b(v, 27);
-  }
-  /**
-   *  Return a new ``bytes28`` type for %%v%%.
-   */
-  static bytes28(v) {
-    return b(v, 28);
-  }
-  /**
-   *  Return a new ``bytes29`` type for %%v%%.
-   */
-  static bytes29(v) {
-    return b(v, 29);
-  }
-  /**
-   *  Return a new ``bytes30`` type for %%v%%.
-   */
-  static bytes30(v) {
-    return b(v, 30);
-  }
-  /**
-   *  Return a new ``bytes31`` type for %%v%%.
-   */
-  static bytes31(v) {
-    return b(v, 31);
-  }
-  /**
-   *  Return a new ``bytes32`` type for %%v%%.
-   */
-  static bytes32(v) {
-    return b(v, 32);
-  }
-  /**
-   *  Return a new ``address`` type for %%v%%.
-   */
-  static address(v) {
-    return new _Typed(_gaurd, "address", v);
-  }
-  /**
-   *  Return a new ``bool`` type for %%v%%.
-   */
-  static bool(v) {
-    return new _Typed(_gaurd, "bool", !!v);
-  }
-  /**
-   *  Return a new ``bytes`` type for %%v%%.
-   */
-  static bytes(v) {
-    return new _Typed(_gaurd, "bytes", v);
-  }
-  /**
-   *  Return a new ``string`` type for %%v%%.
-   */
-  static string(v) {
-    return new _Typed(_gaurd, "string", v);
-  }
-  /**
-   *  Return a new ``array`` type for %%v%%, allowing %%dynamic%% length.
-   */
-  static array(v, dynamic) {
-    throw new Error("not implemented yet");
-  }
-  /**
-   *  Return a new ``tuple`` type for %%v%%, with the optional %%name%%.
-   */
-  static tuple(v, name) {
-    throw new Error("not implemented yet");
-  }
-  /**
-   *  Return a new ``uint8`` type for %%v%%.
-   */
-  static overrides(v) {
-    return new _Typed(_gaurd, "overrides", Object.assign({}, v));
-  }
-  /**
-   *  Returns true only if %%value%% is a [[Typed]] instance.
-   */
-  static isTyped(value) {
-    return value && typeof value === "object" && "_typedSymbol" in value && value._typedSymbol === _typedSymbol;
-  }
-  /**
-   *  If the value is a [[Typed]] instance, validates the underlying value
-   *  and returns it, otherwise returns value directly.
-   *
-   *  This is useful for functions that with to accept either a [[Typed]]
-   *  object or values.
-   */
-  static dereference(value, type) {
-    if (_Typed.isTyped(value)) {
-      if (value.type !== type) {
-        throw new Error(`invalid type: expecetd ${type}, got ${value.type}`);
+    return dir + sep + base;
+  }
+  var posix = {
+    // path.resolve([from ...], to)
+    resolve: function resolve() {
+      var resolvedPath = "";
+      var resolvedAbsolute = false;
+      var cwd;
+      for (var i = arguments.length - 1; i >= -1 && !resolvedAbsolute; i--) {
+        var path;
+        if (i >= 0)
+          path = arguments[i];
+        else {
+          if (cwd === void 0)
+            cwd = process$1.cwd();
+          path = cwd;
+        }
+        assertPath(path);
+        if (path.length === 0) {
+          continue;
+        }
+        resolvedPath = path + "/" + resolvedPath;
+        resolvedAbsolute = path.charCodeAt(0) === 47;
       }
-      return value.value;
-    }
-    return value;
-  }
-};
-_options = new WeakMap();
-let Typed = _Typed;
+      resolvedPath = normalizeStringPosix(resolvedPath, !resolvedAbsolute);
+      if (resolvedAbsolute) {
+        if (resolvedPath.length > 0)
+          return "/" + resolvedPath;
+        else
+          return "/";
+      } else if (resolvedPath.length > 0) {
+        return resolvedPath;
+      } else {
+        return ".";
+      }
+    },
+    normalize: function normalize(path) {
+      assertPath(path);
+      if (path.length === 0) return ".";
+      var isAbsolute = path.charCodeAt(0) === 47;
+      var trailingSeparator = path.charCodeAt(path.length - 1) === 47;
+      path = normalizeStringPosix(path, !isAbsolute);
+      if (path.length === 0 && !isAbsolute) path = ".";
+      if (path.length > 0 && trailingSeparator) path += "/";
+      if (isAbsolute) return "/" + path;
+      return path;
+    },
+    isAbsolute: function isAbsolute(path) {
+      assertPath(path);
+      return path.length > 0 && path.charCodeAt(0) === 47;
+    },
+    join: function join() {
+      if (arguments.length === 0)
+        return ".";
+      var joined;
+      for (var i = 0; i < arguments.length; ++i) {
+        var arg = arguments[i];
+        assertPath(arg);
+        if (arg.length > 0) {
+          if (joined === void 0)
+            joined = arg;
+          else
+            joined += "/" + arg;
+        }
+      }
+      if (joined === void 0)
+        return ".";
+      return posix.normalize(joined);
+    },
+    relative: function relative(from, to) {
+      assertPath(from);
+      assertPath(to);
+      if (from === to) return "";
+      from = posix.resolve(from);
+      to = posix.resolve(to);
+      if (from === to) return "";
+      var fromStart = 1;
+      for (; fromStart < from.length; ++fromStart) {
+        if (from.charCodeAt(fromStart) !== 47)
+          break;
+      }
+      var fromEnd = from.length;
+      var fromLen = fromEnd - fromStart;
+      var toStart = 1;
+      for (; toStart < to.length; ++toStart) {
+        if (to.charCodeAt(toStart) !== 47)
+          break;
+      }
+      var toEnd = to.length;
+      var toLen = toEnd - toStart;
+      var length = fromLen < toLen ? fromLen : toLen;
+      var lastCommonSep = -1;
+      var i = 0;
+      for (; i <= length; ++i) {
+        if (i === length) {
+          if (toLen > length) {
+            if (to.charCodeAt(toStart + i) === 47) {
+              return to.slice(toStart + i + 1);
+            } else if (i === 0) {
+              return to.slice(toStart + i);
+            }
+          } else if (fromLen > length) {
+            if (from.charCodeAt(fromStart + i) === 47) {
+              lastCommonSep = i;
+            } else if (i === 0) {
+              lastCommonSep = 0;
+            }
+          }
+          break;
+        }
+        var fromCode = from.charCodeAt(fromStart + i);
+        var toCode = to.charCodeAt(toStart + i);
+        if (fromCode !== toCode)
+          break;
+        else if (fromCode === 47)
+          lastCommonSep = i;
+      }
+      var out = "";
+      for (i = fromStart + lastCommonSep + 1; i <= fromEnd; ++i) {
+        if (i === fromEnd || from.charCodeAt(i) === 47) {
+          if (out.length === 0)
+            out += "..";
+          else
+            out += "/..";
+        }
+      }
+      if (out.length > 0)
+        return out + to.slice(toStart + lastCommonSep);
+      else {
+        toStart += lastCommonSep;
+        if (to.charCodeAt(toStart) === 47)
+          ++toStart;
+        return to.slice(toStart);
+      }
+    },
+    _makeLong: function _makeLong(path) {
+      return path;
+    },
+    dirname: function dirname(path) {
+      assertPath(path);
+      if (path.length === 0) return ".";
+      var code = path.charCodeAt(0);
+      var hasRoot = code === 47;
+      var end = -1;
+      var matchedSlash = true;
+      for (var i = path.length - 1; i >= 1; --i) {
+        code = path.charCodeAt(i);
+        if (code === 47) {
+          if (!matchedSlash) {
+            end = i;
+            break;
+          }
+        } else {
+          matchedSlash = false;
+        }
+      }
+      if (end === -1) return hasRoot ? "/" : ".";
+      if (hasRoot && end === 1) return "//";
+      return path.slice(0, end);
+    },
+    basename: function basename(path, ext) {
+      if (ext !== void 0 && typeof ext !== "string") throw new TypeError('"ext" argument must be a string');
+      assertPath(path);
+      var start = 0;
+      var end = -1;
+      var matchedSlash = true;
+      var i;
+      if (ext !== void 0 && ext.length > 0 && ext.length <= path.length) {
+        if (ext.length === path.length && ext === path) return "";
+        var extIdx = ext.length - 1;
+        var firstNonSlashEnd = -1;
+        for (i = path.length - 1; i >= 0; --i) {
+          var code = path.charCodeAt(i);
+          if (code === 47) {
+            if (!matchedSlash) {
+              start = i + 1;
+              break;
+            }
+          } else {
+            if (firstNonSlashEnd === -1) {
+              matchedSlash = false;
+              firstNonSlashEnd = i + 1;
+            }
+            if (extIdx >= 0) {
+              if (code === ext.charCodeAt(extIdx)) {
+                if (--extIdx === -1) {
+                  end = i;
+                }
+              } else {
+                extIdx = -1;
+                end = firstNonSlashEnd;
+              }
+            }
+          }
+        }
+        if (start === end) end = firstNonSlashEnd;
+        else if (end === -1) end = path.length;
+        return path.slice(start, end);
+      } else {
+        for (i = path.length - 1; i >= 0; --i) {
+          if (path.charCodeAt(i) === 47) {
+            if (!matchedSlash) {
+              start = i + 1;
+              break;
+            }
+          } else if (end === -1) {
+            matchedSlash = false;
+            end = i + 1;
+          }
+        }
+        if (end === -1) return "";
+        return path.slice(start, end);
+      }
+    },
+    extname: function extname(path) {
+      assertPath(path);
+      var startDot = -1;
+      var startPart = 0;
+      var end = -1;
+      var matchedSlash = true;
+      var preDotState = 0;
+      for (var i = path.length - 1; i >= 0; --i) {
+        var code = path.charCodeAt(i);
+        if (code === 47) {
+          if (!matchedSlash) {
+            startPart = i + 1;
+            break;
+          }
+          continue;
+        }
+        if (end === -1) {
+          matchedSlash = false;
+          end = i + 1;
+        }
+        if (code === 46) {
+          if (startDot === -1)
+            startDot = i;
+          else if (preDotState !== 1)
+            preDotState = 1;
+        } else if (startDot !== -1) {
+          preDotState = -1;
+        }
+      }
+      if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot
+      preDotState === 0 || // The (right-most) trimmed path component is exactly '..'
+      preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+        return "";
+      }
+      return path.slice(startDot, end);
+    },
+    format: function format(pathObject) {
+      if (pathObject === null || typeof pathObject !== "object") {
+        throw new TypeError('The "pathObject" argument must be of type Object. Received type ' + typeof pathObject);
+      }
+      return _format("/", pathObject);
+    },
+    parse: function parse(path) {
+      assertPath(path);
+      var ret = { root: "", dir: "", base: "", ext: "", name: "" };
+      if (path.length === 0) return ret;
+      var code = path.charCodeAt(0);
+      var isAbsolute = code === 47;
+      var start;
+      if (isAbsolute) {
+        ret.root = "/";
+        start = 1;
+      } else {
+        start = 0;
+      }
+      var startDot = -1;
+      var startPart = 0;
+      var end = -1;
+      var matchedSlash = true;
+      var i = path.length - 1;
+      var preDotState = 0;
+      for (; i >= start; --i) {
+        code = path.charCodeAt(i);
+        if (code === 47) {
+          if (!matchedSlash) {
+            startPart = i + 1;
+            break;
+          }
+          continue;
+        }
+        if (end === -1) {
+          matchedSlash = false;
+          end = i + 1;
+        }
+        if (code === 46) {
+          if (startDot === -1) startDot = i;
+          else if (preDotState !== 1) preDotState = 1;
+        } else if (startDot !== -1) {
+          preDotState = -1;
+        }
+      }
+      if (startDot === -1 || end === -1 || // We saw a non-dot character immediately before the dot
+      preDotState === 0 || // The (right-most) trimmed path component is exactly '..'
+      preDotState === 1 && startDot === end - 1 && startDot === startPart + 1) {
+        if (end !== -1) {
+          if (startPart === 0 && isAbsolute) ret.base = ret.name = path.slice(1, end);
+          else ret.base = ret.name = path.slice(startPart, end);
+        }
+      } else {
+        if (startPart === 0 && isAbsolute) {
+          ret.name = path.slice(1, startDot);
+          ret.base = path.slice(1, end);
+        } else {
+          ret.name = path.slice(startPart, startDot);
+          ret.base = path.slice(startPart, end);
+        }
+        ret.ext = path.slice(startDot, end);
+      }
+      if (startPart > 0) ret.dir = path.slice(0, startPart - 1);
+      else if (isAbsolute) ret.dir = "/";
+      return ret;
+    },
+    sep: "/",
+    delimiter: ":",
+    win32: null,
+    posix: null
+  };
+  posix.posix = posix;
+  pathBrowserify = posix;
+  return pathBrowserify;
+}
 export {
-  Typed
+  requirePathBrowserify as __require
 };
 //# sourceMappingURL=standards-sdk.es74.js.map