web-dc-api 0.0.58 → 0.0.60

package/dist/cjs/node_modules/interface-datastore/dist/src/key.js

@@ -0,0 +1,403 @@
+'use strict';
+
+var fromString = require('../../../uint8arrays/dist/src/from-string.js');
+var toString = require('../../../uint8arrays/dist/src/to-string.js');
+
+const pathSepS = '/';
+const pathSepB = new TextEncoder().encode(pathSepS);
+const pathSep = pathSepB[0];
+/**
+ * A Key represents the unique identifier of an object.
+ * Our Key scheme is inspired by file systems and Google App Engine key model.
+ * Keys are meant to be unique across a system. Keys are hierarchical,
+ * incorporating more and more specific namespaces. Thus keys can be deemed
+ * 'children' or 'ancestors' of other keys:
+ * - `new Key('/Comedy')`
+ * - `new Key('/Comedy/MontyPython')`
+ * Also, every namespace can be parametrized to embed relevant object
+ * information. For example, the Key `name` (most specific namespace) could
+ * include the object type:
+ * - `new Key('/Comedy/MontyPython/Actor:JohnCleese')`
+ * - `new Key('/Comedy/MontyPython/Sketch:CheeseShop')`
+ * - `new Key('/Comedy/MontyPython/Sketch:CheeseShop/Character:Mousebender')`
+ *
+ */
+class Key {
+  _buf;
+  /**
+   * @param {string | Uint8Array} s
+   * @param {boolean} [clean]
+   */
+  constructor(s, clean) {
+    if (typeof s === 'string') {
+      this._buf = fromString.fromString(s);
+    } else if (s instanceof Uint8Array) {
+      this._buf = s;
+    } else {
+      throw new Error('Invalid key, should be String of Uint8Array');
+    }
+    if (clean == null) {
+      clean = true;
+    }
+    if (clean) {
+      this.clean();
+    }
+    if (this._buf.byteLength === 0 || this._buf[0] !== pathSep) {
+      throw new Error('Invalid key');
+    }
+  }
+  /**
+   * Convert to the string representation
+   *
+   * @param {import('uint8arrays/to-string').SupportedEncodings} [encoding] - The encoding to use.
+   * @returns {string}
+   */
+  toString() {
+    let encoding = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 'utf8';
+    return toString.toString(this._buf, encoding);
+  }
+  /**
+   * Return the Uint8Array representation of the key
+   *
+   * @returns {Uint8Array}
+   */
+  uint8Array() {
+    return this._buf;
+  }
+  /**
+   * Return string representation of the key
+   *
+   * @returns {string}
+   */
+  get [Symbol.toStringTag]() {
+    return `Key(${this.toString()})`;
+  }
+  /**
+   * Constructs a key out of a namespace array.
+   *
+   * @param {Array<string>} list - The array of namespaces
+   * @returns {Key}
+   *
+   * @example
+   * ```js
+   * Key.withNamespaces(['one', 'two'])
+   * // => Key('/one/two')
+   * ```
+   */
+  static withNamespaces(list) {
+    return new Key(list.join(pathSepS));
+  }
+  /**
+   * Returns a randomly (uuid) generated key.
+   *
+   * @returns {Key}
+   *
+   * @example
+   * ```js
+   * Key.random()
+   * // => Key('/344502982398')
+   * ```
+   */
+  static random() {
+    return new Key(Math.random().toString().substring(2));
+  }
+  /**
+   * @param {*} other
+   */
+  static asKey(other) {
+    if (other instanceof Uint8Array || typeof other === 'string') {
+      // we can create a key from this
+      return new Key(other);
+    }
+    if (typeof other.uint8Array === 'function') {
+      // this is an older version or may have crossed the esm/cjs boundary
+      return new Key(other.uint8Array());
+    }
+    return null;
+  }
+  /**
+   * Cleanup the current key
+   *
+   * @returns {void}
+   */
+  clean() {
+    if (this._buf == null || this._buf.byteLength === 0) {
+      this._buf = pathSepB;
+    }
+    if (this._buf[0] !== pathSep) {
+      const bytes = new Uint8Array(this._buf.byteLength + 1);
+      bytes.fill(pathSep, 0, 1);
+      bytes.set(this._buf, 1);
+      this._buf = bytes;
+    }
+    // normalize does not remove trailing slashes
+    while (this._buf.byteLength > 1 && this._buf[this._buf.byteLength - 1] === pathSep) {
+      this._buf = this._buf.subarray(0, -1);
+    }
+  }
+  /**
+   * Check if the given key is sorted lower than ourself.
+   *
+   * @param {Key} key - The other Key to check against
+   * @returns {boolean}
+   */
+  less(key) {
+    const list1 = this.list();
+    const list2 = key.list();
+    for (let i = 0; i < list1.length; i++) {
+      if (list2.length < i + 1) {
+        return false;
+      }
+      const c1 = list1[i];
+      const c2 = list2[i];
+      if (c1 < c2) {
+        return true;
+      } else if (c1 > c2) {
+        return false;
+      }
+    }
+    return list1.length < list2.length;
+  }
+  /**
+   * Returns the key with all parts in reversed order.
+   *
+   * @returns {Key}
+   *
+   * @example
+   * ```js
+   * new Key('/Comedy/MontyPython/Actor:JohnCleese').reverse()
+   * // => Key('/Actor:JohnCleese/MontyPython/Comedy')
+   * ```
+   */
+  reverse() {
+    return Key.withNamespaces(this.list().slice().reverse());
+  }
+  /**
+   * Returns the `namespaces` making up this Key.
+   *
+   * @returns {Array<string>}
+   */
+  namespaces() {
+    return this.list();
+  }
+  /**
+   * Returns the "base" namespace of this key.
+   *
+   * @returns {string}
+   *
+   * @example
+   * ```js
+   * new Key('/Comedy/MontyPython/Actor:JohnCleese').baseNamespace()
+   * // => 'Actor:JohnCleese'
+   * ```
+   */
+  baseNamespace() {
+    const ns = this.namespaces();
+    return ns[ns.length - 1];
+  }
+  /**
+   * Returns the `list` representation of this key.
+   *
+   * @returns {Array<string>}
+   *
+   * @example
+   * ```js
+   * new Key('/Comedy/MontyPython/Actor:JohnCleese').list()
+   * // => ['Comedy', 'MontyPythong', 'Actor:JohnCleese']
+   * ```
+   */
+  list() {
+    return this.toString().split(pathSepS).slice(1);
+  }
+  /**
+   * Returns the "type" of this key (value of last namespace).
+   *
+   * @returns {string}
+   *
+   * @example
+   * ```js
+   * new Key('/Comedy/MontyPython/Actor:JohnCleese').type()
+   * // => 'Actor'
+   * ```
+   */
+  type() {
+    return namespaceType(this.baseNamespace());
+  }
+  /**
+   * Returns the "name" of this key (field of last namespace).
+   *
+   * @returns {string}
+   *
+   * @example
+   * ```js
+   * new Key('/Comedy/MontyPython/Actor:JohnCleese').name()
+   * // => 'JohnCleese'
+   * ```
+   */
+  name() {
+    return namespaceValue(this.baseNamespace());
+  }
+  /**
+   * Returns an "instance" of this type key (appends value to namespace).
+   *
+   * @param {string} s - The string to append.
+   * @returns {Key}
+   *
+   * @example
+   * ```js
+   * new Key('/Comedy/MontyPython/Actor').instance('JohnClesse')
+   * // => Key('/Comedy/MontyPython/Actor:JohnCleese')
+   * ```
+   */
+  instance(s) {
+    return new Key(this.toString() + ':' + s);
+  }
+  /**
+   * Returns the "path" of this key (parent + type).
+   *
+   * @returns {Key}
+   *
+   * @example
+   * ```js
+   * new Key('/Comedy/MontyPython/Actor:JohnCleese').path()
+   * // => Key('/Comedy/MontyPython/Actor')
+   * ```
+   */
+  path() {
+    let p = this.parent().toString();
+    if (!p.endsWith(pathSepS)) {
+      p += pathSepS;
+    }
+    p += this.type();
+    return new Key(p);
+  }
+  /**
+   * Returns the `parent` Key of this Key.
+   *
+   * @returns {Key}
+   *
+   * @example
+   * ```js
+   * new Key("/Comedy/MontyPython/Actor:JohnCleese").parent()
+   * // => Key("/Comedy/MontyPython")
+   * ```
+   */
+  parent() {
+    const list = this.list();
+    if (list.length === 1) {
+      return new Key(pathSepS);
+    }
+    return new Key(list.slice(0, -1).join(pathSepS));
+  }
+  /**
+   * Returns the `child` Key of this Key.
+   *
+   * @param {Key} key - The child Key to add
+   * @returns {Key}
+   *
+   * @example
+   * ```js
+   * new Key('/Comedy/MontyPython').child(new Key('Actor:JohnCleese'))
+   * // => Key('/Comedy/MontyPython/Actor:JohnCleese')
+   * ```
+   */
+  child(key) {
+    if (this.toString() === pathSepS) {
+      return key;
+    } else if (key.toString() === pathSepS) {
+      return this;
+    }
+    return new Key(this.toString() + key.toString(), false);
+  }
+  /**
+   * Returns whether this key is a prefix of `other`
+   *
+   * @param {Key} other - The other key to test against
+   * @returns {boolean}
+   *
+   * @example
+   * ```js
+   * new Key('/Comedy').isAncestorOf('/Comedy/MontyPython')
+   * // => true
+   * ```
+   */
+  isAncestorOf(other) {
+    if (other.toString() === this.toString()) {
+      return false;
+    }
+    return other.toString().startsWith(this.toString());
+  }
+  /**
+   * Returns whether this key is a contains another as prefix.
+   *
+   * @param {Key} other - The other Key to test against
+   * @returns {boolean}
+   *
+   * @example
+   * ```js
+   * new Key('/Comedy/MontyPython').isDecendantOf('/Comedy')
+   * // => true
+   * ```
+   */
+  isDecendantOf(other) {
+    if (other.toString() === this.toString()) {
+      return false;
+    }
+    return this.toString().startsWith(other.toString());
+  }
+  /**
+   * Checks if this key has only one namespace.
+   *
+   * @returns {boolean}
+   */
+  isTopLevel() {
+    return this.list().length === 1;
+  }
+  /**
+   * Concats one or more Keys into one new Key.
+   *
+   * @param {Array<Key>} keys - The array of keys to concatenate
+   * @returns {Key}
+   */
+  concat() {
+    for (var _len = arguments.length, keys = new Array(_len), _key = 0; _key < _len; _key++) {
+      keys[_key] = arguments[_key];
+    }
+    return Key.withNamespaces([...this.namespaces(), ...flatten(keys.map(key => key.namespaces()))]);
+  }
+}
+/**
+ * The first component of a namespace. `foo` in `foo:bar`
+ *
+ * @param {string} ns
+ * @returns {string}
+ */
+function namespaceType(ns) {
+  const parts = ns.split(':');
+  if (parts.length < 2) {
+    return '';
+  }
+  return parts.slice(0, -1).join(':');
+}
+/**
+ * The last component of a namespace, `baz` in `foo:bar:baz`.
+ *
+ * @param {string} ns
+ * @returns {string}
+ */
+function namespaceValue(ns) {
+  const parts = ns.split(':');
+  return parts[parts.length - 1];
+}
+/**
+ * Flatten array of arrays (only one level)
+ *
+ * @template T
+ * @param {Array<any>} arr
+ * @returns {T[]}
+ */
+function flatten(arr) {
+  return [].concat(...arr);
+}
+
+exports.Key = Key;

package/dist/cjs/node_modules/is-arguments/index.js

@@ -0,0 +1,42 @@
+'use strict';
+
+var shams = require('../has-tostringtag/shams.js');
+var index = require('../call-bound/index.js');
+
+var isArguments;
+var hasRequiredIsArguments;
+function requireIsArguments() {
+  if (hasRequiredIsArguments) return isArguments;
+  hasRequiredIsArguments = 1;
+  var hasToStringTag = shams.__require()();
+  var callBound = /*@__PURE__*/index.__require();
+  var $toString = callBound('Object.prototype.toString');
+
+  /** @type {import('.')} */
+  var isStandardArguments = function isArguments(value) {
+    if (hasToStringTag && value && typeof value === 'object' && Symbol.toStringTag in value) {
+      return false;
+    }
+    return $toString(value) === '[object Arguments]';
+  };
+
+  /** @type {import('.')} */
+  var isLegacyArguments = function isArguments(value) {
+    if (isStandardArguments(value)) {
+      return true;
+    }
+    return value !== null && typeof value === 'object' && 'length' in value && typeof value.length === 'number' && value.length >= 0 && $toString(value) !== '[object Array]' && 'callee' in value && $toString(value.callee) === '[object Function]';
+  };
+  var supportsStandardArguments = function () {
+    return isStandardArguments(arguments);
+  }();
+
+  // @ts-expect-error TODO make this not error
+  isStandardArguments.isLegacyArguments = isLegacyArguments; // for tests
+
+  /** @type {import('.')} */
+  isArguments = supportsStandardArguments ? isStandardArguments : isLegacyArguments;
+  return isArguments;
+}
+
+exports.__require = requireIsArguments;

package/dist/cjs/node_modules/is-callable/index.js

@@ -0,0 +1,128 @@
+'use strict';
+
+var isCallable;
+var hasRequiredIsCallable;
+function requireIsCallable() {
+  if (hasRequiredIsCallable) return isCallable;
+  hasRequiredIsCallable = 1;
+  var fnToStr = Function.prototype.toString;
+  var reflectApply = typeof Reflect === 'object' && Reflect !== null && Reflect.apply;
+  var badArrayLike;
+  var isCallableMarker;
+  if (typeof reflectApply === 'function' && typeof Object.defineProperty === 'function') {
+    try {
+      badArrayLike = Object.defineProperty({}, 'length', {
+        get: function () {
+          throw isCallableMarker;
+        }
+      });
+      isCallableMarker = {};
+      // eslint-disable-next-line no-throw-literal
+      reflectApply(function () {
+        throw 42;
+      }, null, badArrayLike);
+    } catch (_) {
+      if (_ !== isCallableMarker) {
+        reflectApply = null;
+      }
+    }
+  } else {
+    reflectApply = null;
+  }
+  var constructorRegex = /^\s*class\b/;
+  var isES6ClassFn = function isES6ClassFunction(value) {
+    try {
+      var fnStr = fnToStr.call(value);
+      return constructorRegex.test(fnStr);
+    } catch (e) {
+      return false; // not a function
+    }
+  };
+  var tryFunctionObject = function tryFunctionToStr(value) {
+    try {
+      if (isES6ClassFn(value)) {
+        return false;
+      }
+      fnToStr.call(value);
+      return true;
+    } catch (e) {
+      return false;
+    }
+  };
+  var toStr = Object.prototype.toString;
+  var objectClass = '[object Object]';
+  var fnClass = '[object Function]';
+  var genClass = '[object GeneratorFunction]';
+  var ddaClass = '[object HTMLAllCollection]'; // IE 11
+  var ddaClass2 = '[object HTML document.all class]';
+  var ddaClass3 = '[object HTMLCollection]'; // IE 9-10
+  var hasToStringTag = typeof Symbol === 'function' && !!Symbol.toStringTag; // better: use `has-tostringtag`
+
+  var isIE68 = !(0 in [,]); // eslint-disable-line no-sparse-arrays, comma-spacing
+
+  var isDDA = function isDocumentDotAll() {
+    return false;
+  };
+  if (typeof document === 'object') {
+    // Firefox 3 canonicalizes DDA to undefined when it's not accessed directly
+    var all = document.all;
+    if (toStr.call(all) === toStr.call(document.all)) {
+      isDDA = function isDocumentDotAll(value) {
+        /* globals document: false */
+        // in IE 6-8, typeof document.all is "object" and it's truthy
+        if ((isIE68 || !value) && (typeof value === 'undefined' || typeof value === 'object')) {
+          try {
+            var str = toStr.call(value);
+            return (str === ddaClass || str === ddaClass2 || str === ddaClass3 // opera 12.16
+            || str === objectClass // IE 6-8
+            ) && value('') == null; // eslint-disable-line eqeqeq
+          } catch (e) {/**/}
+        }
+        return false;
+      };
+    }
+  }
+  isCallable = reflectApply ? function isCallable(value) {
+    if (isDDA(value)) {
+      return true;
+    }
+    if (!value) {
+      return false;
+    }
+    if (typeof value !== 'function' && typeof value !== 'object') {
+      return false;
+    }
+    try {
+      reflectApply(value, null, badArrayLike);
+    } catch (e) {
+      if (e !== isCallableMarker) {
+        return false;
+      }
+    }
+    return !isES6ClassFn(value) && tryFunctionObject(value);
+  } : function isCallable(value) {
+    if (isDDA(value)) {
+      return true;
+    }
+    if (!value) {
+      return false;
+    }
+    if (typeof value !== 'function' && typeof value !== 'object') {
+      return false;
+    }
+    if (hasToStringTag) {
+      return tryFunctionObject(value);
+    }
+    if (isES6ClassFn(value)) {
+      return false;
+    }
+    var strClass = toStr.call(value);
+    if (strClass !== fnClass && strClass !== genClass && !/^\[object HTML/.test(strClass)) {
+      return false;
+    }
+    return tryFunctionObject(value);
+  };
+  return isCallable;
+}
+
+exports.__require = requireIsCallable;

package/dist/cjs/node_modules/is-generator-function/index.js

@@ -0,0 +1,58 @@
+'use strict';
+
+var index$2 = require('../call-bound/index.js');
+var index = require('../safe-regex-test/index.js');
+var shams = require('../has-tostringtag/shams.js');
+var index$1 = require('../get-proto/index.js');
+
+var isGeneratorFunction;
+var hasRequiredIsGeneratorFunction;
+function requireIsGeneratorFunction() {
+  if (hasRequiredIsGeneratorFunction) return isGeneratorFunction;
+  hasRequiredIsGeneratorFunction = 1;
+  var callBound = /*@__PURE__*/index$2.__require();
+  var safeRegexTest = /*@__PURE__*/index.__require();
+  var isFnRegex = safeRegexTest(/^\s*(?:function)?\*/);
+  var hasToStringTag = shams.__require()();
+  var getProto = index$1.__require();
+  var toStr = callBound('Object.prototype.toString');
+  var fnToStr = callBound('Function.prototype.toString');
+  var getGeneratorFunc = function () {
+    // eslint-disable-line consistent-return
+    if (!hasToStringTag) {
+      return false;
+    }
+    try {
+      return Function('return function*() {}')();
+    } catch (e) {}
+  };
+  /** @type {undefined | false | null | GeneratorFunctionConstructor} */
+  var GeneratorFunction;
+
+  /** @type {import('.')} */
+  isGeneratorFunction = function isGeneratorFunction(fn) {
+    if (typeof fn !== 'function') {
+      return false;
+    }
+    if (isFnRegex(fnToStr(fn))) {
+      return true;
+    }
+    if (!hasToStringTag) {
+      var str = toStr(fn);
+      return str === '[object GeneratorFunction]';
+    }
+    if (!getProto) {
+      return false;
+    }
+    if (typeof GeneratorFunction === 'undefined') {
+      var generatorFunc = getGeneratorFunc();
+      GeneratorFunction = generatorFunc
+      // eslint-disable-next-line no-extra-parens
+      ? (/** @type {GeneratorFunctionConstructor} */getProto(generatorFunc)) : false;
+    }
+    return getProto(fn) === GeneratorFunction;
+  };
+  return isGeneratorFunction;
+}
+
+exports.__require = requireIsGeneratorFunction;

package/dist/cjs/node_modules/is-regex/index.js

@@ -0,0 +1,77 @@
+'use strict';
+
+var index = require('../call-bound/index.js');
+var shams = require('../has-tostringtag/shams.js');
+var index$2 = require('../hasown/index.js');
+var index$1 = require('../gopd/index.js');
+
+var isRegex;
+var hasRequiredIsRegex;
+function requireIsRegex() {
+  if (hasRequiredIsRegex) return isRegex;
+  hasRequiredIsRegex = 1;
+  var callBound = /*@__PURE__*/index.__require();
+  var hasToStringTag = shams.__require()();
+  var hasOwn = /*@__PURE__*/index$2.__require();
+  var gOPD = /*@__PURE__*/index$1.__require();
+
+  /** @type {import('.')} */
+  var fn;
+  if (hasToStringTag) {
+    /** @type {(receiver: ThisParameterType<typeof RegExp.prototype.exec>, ...args: Parameters<typeof RegExp.prototype.exec>) => ReturnType<typeof RegExp.prototype.exec>} */
+    var $exec = callBound('RegExp.prototype.exec');
+    /** @type {object} */
+    var isRegexMarker = {};
+    var throwRegexMarker = function () {
+      throw isRegexMarker;
+    };
+    /** @type {{ toString(): never, valueOf(): never, [Symbol.toPrimitive]?(): never }} */
+    var badStringifier = {
+      toString: throwRegexMarker,
+      valueOf: throwRegexMarker
+    };
+    if (typeof Symbol.toPrimitive === 'symbol') {
+      badStringifier[Symbol.toPrimitive] = throwRegexMarker;
+    }
+
+    /** @type {import('.')} */
+    // @ts-expect-error TS can't figure out that the $exec call always throws
+    // eslint-disable-next-line consistent-return
+    fn = function isRegex(value) {
+      if (!value || typeof value !== 'object') {
+        return false;
+      }
+
+      // eslint-disable-next-line no-extra-parens
+      var descriptor = /** @type {NonNullable<typeof gOPD>} */gOPD(/** @type {{ lastIndex?: unknown }} */value, 'lastIndex');
+      var hasLastIndexDataProperty = descriptor && hasOwn(descriptor, 'value');
+      if (!hasLastIndexDataProperty) {
+        return false;
+      }
+      try {
+        // eslint-disable-next-line no-extra-parens
+        $exec(value, /** @type {string} */ /** @type {unknown} */badStringifier);
+      } catch (e) {
+        return e === isRegexMarker;
+      }
+    };
+  } else {
+    /** @type {(receiver: ThisParameterType<typeof Object.prototype.toString>, ...args: Parameters<typeof Object.prototype.toString>) => ReturnType<typeof Object.prototype.toString>} */
+    var $toString = callBound('Object.prototype.toString');
+    /** @const @type {'[object RegExp]'} */
+    var regexClass = '[object RegExp]';
+
+    /** @type {import('.')} */
+    fn = function isRegex(value) {
+      // In older browsers, typeof regex incorrectly returns 'function'
+      if (!value || typeof value !== 'object' && typeof value !== 'function') {
+        return false;
+      }
+      return $toString(value) === regexClass;
+    };
+  }
+  isRegex = fn;
+  return isRegex;
+}
+
+exports.__require = requireIsRegex;