@templmf/temp-solf-lmf 0.0.146 → 0.0.148

package/new/pfnededegaaopdmhkdmcofjmoldfiped/3.5.0_0/lib/zero-dependencies/fake-indexeddb/lib/FakeDOMStringList.js

@@ -1,72 +0,0 @@
-class FakeDOMStringList extends Array {
-  contains(value) {
-    for (const value2 of this) {
-      if (value === value2) {
-        return true;
-      }
-    }
-    return false;
-  }
-  item(i) {
-    if (i < 0 || i >= this.length) {
-      return null;
-    }
-    return this[i];
-  }
-
-  // Used internally, should not be used by others. I could maybe get rid of these and replace rather than mutate, but too lazy to check the spec.
-  _push(...values) {
-    return Array.prototype.push.call(this, ...values);
-  }
-  _sort(...values) {
-    return Array.prototype.sort.call(this, ...values);
-  }
-}
-
-// Would be nice to remove these properties to fix https://github.com/dumbmatter/fakeIndexedDB/issues/66 but for some reason it breaks Dexie - see test/dexie.js and FakeDOMStringList tests
-/*
-// From https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Array
-const arrayPropertiesToDelete = ["from", "isArray", "of"];
-const arrayMethodsToDelete = [
-    "at",
-    "concat",
-    "copyWithin",
-    "entries",
-    "every",
-    "fill",
-    "filter",
-    "find",
-    "findIndex",
-    "flat",
-    "flatMap",
-    "forEach",
-    "includes",
-    "indexOf",
-    "join",
-    "keys",
-    "lastIndexOf",
-    "map",
-    "pop",
-    "push",
-    "reduce",
-    "reduceRight",
-    "reverse",
-    "shift",
-    "slice",
-    "some",
-    "sort",
-    "splice",
-    "unshift",
-    "values",
-];
-
-// Set to undefined rather than delete, so it doesn't go up the chain to Array. Not perfect, but good enough?
-for (const property of arrayPropertiesToDelete) {
-    (FakeDOMStringList as any)[property] = undefined;
-}
-for (const property of arrayMethodsToDelete) {
-    (FakeDOMStringList as any).prototype[property] = undefined;
-}
-*/
-
-export default FakeDOMStringList;

package/new/pfnededegaaopdmhkdmcofjmoldfiped/3.5.0_0/lib/zero-dependencies/fake-indexeddb/lib/FakeEvent.js

@@ -1,38 +0,0 @@
-class Event {
-  eventPath = [];
-  NONE = 0;
-  CAPTURING_PHASE = 1;
-  AT_TARGET = 2;
-  BUBBLING_PHASE = 3;
-
-  // Flags
-  propagationStopped = false;
-  immediatePropagationStopped = false;
-  canceled = false;
-  initialized = true;
-  dispatched = false;
-  target = null;
-  currentTarget = null;
-  eventPhase = 0;
-  defaultPrevented = false;
-  isTrusted = false;
-  timeStamp = Date.now();
-  constructor(type, eventInitDict = {}) {
-    this.type = type;
-    this.bubbles = eventInitDict.bubbles !== undefined ? eventInitDict.bubbles : false;
-    this.cancelable = eventInitDict.cancelable !== undefined ? eventInitDict.cancelable : false;
-  }
-  preventDefault() {
-    if (this.cancelable) {
-      this.canceled = true;
-    }
-  }
-  stopPropagation() {
-    this.propagationStopped = true;
-  }
-  stopImmediatePropagation() {
-    this.propagationStopped = true;
-    this.immediatePropagationStopped = true;
-  }
-}
-export default Event;

package/new/pfnededegaaopdmhkdmcofjmoldfiped/3.5.0_0/lib/zero-dependencies/fake-indexeddb/lib/FakeEventTarget.js

@@ -1,104 +0,0 @@
-import { InvalidStateError } from "./errors.js";
-const stopped = (event, listener) => {
-  return event.immediatePropagationStopped || event.eventPhase === event.CAPTURING_PHASE && listener.capture === false || event.eventPhase === event.BUBBLING_PHASE && listener.capture === true;
-};
-
-// http://www.w3.org/TR/dom/#concept-event-listener-invoke
-const invokeEventListeners = (event, obj) => {
-  event.currentTarget = obj;
-
-  // The callback might cause obj.listeners to mutate as we traverse it.
-  // Take a copy of the array so that nothing sneaks in and we don't lose
-  // our place.
-  for (const listener of obj.listeners.slice()) {
-    if (event.type !== listener.type || stopped(event, listener)) {
-      continue;
-    }
-
-    // @ts-ignore
-    listener.callback.call(event.currentTarget, event);
-  }
-  const typeToProp = {
-    abort: "onabort",
-    blocked: "onblocked",
-    complete: "oncomplete",
-    error: "onerror",
-    success: "onsuccess",
-    upgradeneeded: "onupgradeneeded",
-    versionchange: "onversionchange"
-  };
-  const prop = typeToProp[event.type];
-  if (prop === undefined) {
-    throw new Error(`Unknown event type: "${event.type}"`);
-  }
-  const callback = event.currentTarget[prop];
-  if (callback) {
-    const listener = {
-      callback,
-      capture: false,
-      type: event.type
-    };
-    if (!stopped(event, listener)) {
-      // @ts-ignore
-      listener.callback.call(event.currentTarget, event);
-    }
-  }
-};
-class FakeEventTarget {
-  listeners = [];
-
-  // These will be overridden in individual subclasses and made not readonly
-
-  addEventListener(type, callback, capture = false) {
-    this.listeners.push({
-      callback,
-      capture,
-      type
-    });
-  }
-  removeEventListener(type, callback, capture = false) {
-    const i = this.listeners.findIndex(listener => {
-      return listener.type === type && listener.callback === callback && listener.capture === capture;
-    });
-    this.listeners.splice(i, 1);
-  }
-
-  // http://www.w3.org/TR/dom/#dispatching-events
-  dispatchEvent(event) {
-    if (event.dispatched || !event.initialized) {
-      throw new InvalidStateError("The object is in an invalid state.");
-    }
-    event.isTrusted = false;
-    event.dispatched = true;
-    event.target = this;
-    // NOT SURE WHEN THIS SHOULD BE SET        event.eventPath = [];
-
-    event.eventPhase = event.CAPTURING_PHASE;
-    for (const obj of event.eventPath) {
-      if (!event.propagationStopped) {
-        invokeEventListeners(event, obj);
-      }
-    }
-    event.eventPhase = event.AT_TARGET;
-    if (!event.propagationStopped) {
-      invokeEventListeners(event, event.target);
-    }
-    if (event.bubbles) {
-      event.eventPath.reverse();
-      event.eventPhase = event.BUBBLING_PHASE;
-      for (const obj of event.eventPath) {
-        if (!event.propagationStopped) {
-          invokeEventListeners(event, obj);
-        }
-      }
-    }
-    event.dispatched = false;
-    event.eventPhase = event.NONE;
-    event.currentTarget = null;
-    if (event.canceled) {
-      return false;
-    }
-    return true;
-  }
-}
-export default FakeEventTarget;

package/new/pfnededegaaopdmhkdmcofjmoldfiped/3.5.0_0/lib/zero-dependencies/fake-indexeddb/lib/Index.js

@@ -1,157 +0,0 @@
-import { ConstraintError } from "./errors.js";
-import extractKey from "./extractKey.js";
-import RecordStore from "./RecordStore.js";
-import valueToKey from "./valueToKey.js";
-
-// http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#dfn-index
-class Index {
-  deleted = false;
-  // Initialized should be used to decide whether to throw an error or abort the versionchange transaction when there is a
-  // constraint
-  initialized = false;
-  records = new RecordStore();
-  constructor(rawObjectStore, name, keyPath, multiEntry, unique) {
-    this.rawObjectStore = rawObjectStore;
-    this.name = name;
-    this.keyPath = keyPath;
-    this.multiEntry = multiEntry;
-    this.unique = unique;
-  }
-
-  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#dfn-steps-for-retrieving-a-value-from-an-index
-  getKey(key) {
-    const record = this.records.get(key);
-    return record !== undefined ? record.value : undefined;
-  }
-
-  // http://w3c.github.io/IndexedDB/#retrieve-multiple-referenced-values-from-an-index
-  getAllKeys(range, count) {
-    if (count === undefined || count === 0) {
-      count = Infinity;
-    }
-    const records = [];
-    for (const record of this.records.values(range)) {
-      records.push(structuredClone(record.value));
-      if (records.length >= count) {
-        break;
-      }
-    }
-    return records;
-  }
-
-  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#index-referenced-value-retrieval-operation
-  getValue(key) {
-    const record = this.records.get(key);
-    return record !== undefined ? this.rawObjectStore.getValue(record.value) : undefined;
-  }
-
-  // http://w3c.github.io/IndexedDB/#retrieve-multiple-referenced-values-from-an-index
-  getAllValues(range, count) {
-    if (count === undefined || count === 0) {
-      count = Infinity;
-    }
-    const records = [];
-    for (const record of this.records.values(range)) {
-      records.push(this.rawObjectStore.getValue(record.value));
-      if (records.length >= count) {
-        break;
-      }
-    }
-    return records;
-  }
-
-  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#dfn-steps-for-storing-a-record-into-an-object-store (step 7)
-  storeRecord(newRecord) {
-    let indexKey;
-    try {
-      indexKey = extractKey(this.keyPath, newRecord.value);
-    } catch (err) {
-      if (err.name === "DataError") {
-        // Invalid key is not an actual error, just means we do not store an entry in this index
-        return;
-      }
-      throw err;
-    }
-    if (!this.multiEntry || !Array.isArray(indexKey)) {
-      try {
-        valueToKey(indexKey);
-      } catch (e) {
-        return;
-      }
-    } else {
-      // remove any elements from index key that are not valid keys and remove any duplicate elements from index
-      // key such that only one instance of the duplicate value remains.
-      const keep = [];
-      for (const part of indexKey) {
-        if (keep.indexOf(part) < 0) {
-          try {
-            keep.push(valueToKey(part));
-          } catch (err) {
-            /* Do nothing */
-          }
-        }
-      }
-      indexKey = keep;
-    }
-    if (!this.multiEntry || !Array.isArray(indexKey)) {
-      if (this.unique) {
-        const existingRecord = this.records.get(indexKey);
-        if (existingRecord) {
-          throw new ConstraintError();
-        }
-      }
-    } else {
-      if (this.unique) {
-        for (const individualIndexKey of indexKey) {
-          const existingRecord = this.records.get(individualIndexKey);
-          if (existingRecord) {
-            throw new ConstraintError();
-          }
-        }
-      }
-    }
-    if (!this.multiEntry || !Array.isArray(indexKey)) {
-      this.records.add({
-        key: indexKey,
-        value: newRecord.key
-      });
-    } else {
-      for (const individualIndexKey of indexKey) {
-        this.records.add({
-          key: individualIndexKey,
-          value: newRecord.key
-        });
-      }
-    }
-  }
-  initialize(transaction) {
-    if (this.initialized) {
-      throw new Error("Index already initialized");
-    }
-    transaction._execRequestAsync({
-      operation: () => {
-        try {
-          // Create index based on current value of objectstore
-          for (const record of this.rawObjectStore.records.values()) {
-            this.storeRecord(record);
-          }
-          this.initialized = true;
-        } catch (err) {
-          // console.error(err);
-          transaction._abort(err.name);
-        }
-      },
-      source: null
-    });
-  }
-  count(range) {
-    let count = 0;
-
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    for (const record of this.records.values(range)) {
-      count += 1;
-    }
-    return count;
-  }
-}
-export default Index;

package/new/pfnededegaaopdmhkdmcofjmoldfiped/3.5.0_0/lib/zero-dependencies/fake-indexeddb/lib/KeyGenerator.js

@@ -1,22 +0,0 @@
-import { ConstraintError } from "./errors.js";
-const MAX_KEY = 9007199254740992;
-class KeyGenerator {
-  // This is kind of wrong. Should start at 1 and increment only after record is saved
-  num = 0;
-  next() {
-    if (this.num >= MAX_KEY) {
-      throw new ConstraintError();
-    }
-    this.num += 1;
-    return this.num;
-  }
-
-  // https://w3c.github.io/IndexedDB/#possibly-update-the-key-generator
-  setIfLarger(num) {
-    const value = Math.floor(Math.min(num, MAX_KEY)) - 1;
-    if (value >= this.num) {
-      this.num = value + 1;
-    }
-  }
-}
-export default KeyGenerator;

package/new/pfnededegaaopdmhkdmcofjmoldfiped/3.5.0_0/lib/zero-dependencies/fake-indexeddb/lib/ObjectStore.js

@@ -1,172 +0,0 @@
-import { ConstraintError, DataError } from "./errors.js";
-import extractKey from "./extractKey.js";
-import KeyGenerator from "./KeyGenerator.js";
-import RecordStore from "./RecordStore.js";
-// http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#dfn-object-store
-class ObjectStore {
-  deleted = false;
-  records = new RecordStore();
-  rawIndexes = new Map();
-  constructor(rawDatabase, name, keyPath, autoIncrement) {
-    this.rawDatabase = rawDatabase;
-    this.keyGenerator = autoIncrement === true ? new KeyGenerator() : null;
-    this.deleted = false;
-    this.name = name;
-    this.keyPath = keyPath;
-    this.autoIncrement = autoIncrement;
-  }
-
-  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#dfn-steps-for-retrieving-a-value-from-an-object-store
-  getKey(key) {
-    const record = this.records.get(key);
-    return record !== undefined ? structuredClone(record.key) : undefined;
-  }
-
-  // http://w3c.github.io/IndexedDB/#retrieve-multiple-keys-from-an-object-store
-  getAllKeys(range, count) {
-    if (count === undefined || count === 0) {
-      count = Infinity;
-    }
-    const records = [];
-    for (const record of this.records.values(range)) {
-      records.push(structuredClone(record.key));
-      if (records.length >= count) {
-        break;
-      }
-    }
-    return records;
-  }
-
-  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#dfn-steps-for-retrieving-a-value-from-an-object-store
-  getValue(key) {
-    const record = this.records.get(key);
-    return record !== undefined ? structuredClone(record.value) : undefined;
-  }
-
-  // http://w3c.github.io/IndexedDB/#retrieve-multiple-values-from-an-object-store
-  getAllValues(range, count) {
-    if (count === undefined || count === 0) {
-      count = Infinity;
-    }
-    const records = [];
-    for (const record of this.records.values(range)) {
-      records.push(structuredClone(record.value));
-      if (records.length >= count) {
-        break;
-      }
-    }
-    return records;
-  }
-
-  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#dfn-steps-for-storing-a-record-into-an-object-store
-  storeRecord(newRecord, noOverwrite, rollbackLog) {
-    if (this.keyPath !== null) {
-      const key = extractKey(this.keyPath, newRecord.value);
-      if (key !== undefined) {
-        newRecord.key = key;
-      }
-    }
-    if (this.keyGenerator !== null && newRecord.key === undefined) {
-      if (rollbackLog) {
-        const keyGeneratorBefore = this.keyGenerator.num;
-        rollbackLog.push(() => {
-          if (this.keyGenerator) {
-            this.keyGenerator.num = keyGeneratorBefore;
-          }
-        });
-      }
-      newRecord.key = this.keyGenerator.next();
-
-      // Set in value if keyPath defiend but led to no key
-      // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#dfn-steps-to-assign-a-key-to-a-value-using-a-key-path
-      if (this.keyPath !== null) {
-        if (Array.isArray(this.keyPath)) {
-          throw new Error("Cannot have an array key path in an object store with a key generator");
-        }
-        let remainingKeyPath = this.keyPath;
-        let object = newRecord.value;
-        let identifier;
-        let i = 0; // Just to run the loop at least once
-        while (i >= 0) {
-          if (typeof object !== "object") {
-            throw new DataError();
-          }
-          i = remainingKeyPath.indexOf(".");
-          if (i >= 0) {
-            identifier = remainingKeyPath.slice(0, i);
-            remainingKeyPath = remainingKeyPath.slice(i + 1);
-            if (!Object.hasOwn(object, identifier)) {
-              object[identifier] = {};
-            }
-            object = object[identifier];
-          }
-        }
-        identifier = remainingKeyPath;
-        object[identifier] = newRecord.key;
-      }
-    } else if (this.keyGenerator !== null && typeof newRecord.key === "number") {
-      this.keyGenerator.setIfLarger(newRecord.key);
-    }
-    const existingRecord = this.records.get(newRecord.key);
-    if (existingRecord) {
-      if (noOverwrite) {
-        throw new ConstraintError();
-      }
-      this.deleteRecord(newRecord.key, rollbackLog);
-    }
-    this.records.add(newRecord);
-    if (rollbackLog) {
-      rollbackLog.push(() => {
-        this.deleteRecord(newRecord.key);
-      });
-    }
-
-    // Update indexes
-    for (const rawIndex of this.rawIndexes.values()) {
-      if (rawIndex.initialized) {
-        rawIndex.storeRecord(newRecord);
-      }
-    }
-    return newRecord.key;
-  }
-
-  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#dfn-steps-for-deleting-records-from-an-object-store
-  deleteRecord(key, rollbackLog) {
-    const deletedRecords = this.records.delete(key);
-    if (rollbackLog) {
-      for (const record of deletedRecords) {
-        rollbackLog.push(() => {
-          this.storeRecord(record, true);
-        });
-      }
-    }
-    for (const rawIndex of this.rawIndexes.values()) {
-      rawIndex.records.deleteByValue(key);
-    }
-  }
-
-  // http://www.w3.org/TR/2015/REC-IndexedDB-20150108/#dfn-steps-for-clearing-an-object-store
-  clear(rollbackLog) {
-    const deletedRecords = this.records.clear();
-    if (rollbackLog) {
-      for (const record of deletedRecords) {
-        rollbackLog.push(() => {
-          this.storeRecord(record, true);
-        });
-      }
-    }
-    for (const rawIndex of this.rawIndexes.values()) {
-      rawIndex.records.clear();
-    }
-  }
-  count(range) {
-    let count = 0;
-
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    for (const record of this.records.values(range)) {
-      count += 1;
-    }
-    return count;
-  }
-}
-export default ObjectStore;

package/new/pfnededegaaopdmhkdmcofjmoldfiped/3.5.0_0/lib/zero-dependencies/fake-indexeddb/lib/RecordStore.js

@@ -1,133 +0,0 @@
-import FDBKeyRange from "../FDBKeyRange.js";
-import { getByKey, getByKeyRange, getIndexByKey, getIndexByKeyGTE, getIndexByKeyRange } from "./binarySearch.js";
-import cmp from "./cmp.js";
-class RecordStore {
-  records = [];
-  get(key) {
-    if (key instanceof FDBKeyRange) {
-      return getByKeyRange(this.records, key);
-    }
-    return getByKey(this.records, key);
-  }
-  add(newRecord) {
-    // Find where to put it so it's sorted by key
-    let i;
-    if (this.records.length === 0) {
-      i = 0;
-    } else {
-      i = getIndexByKeyGTE(this.records, newRecord.key);
-      if (i === -1) {
-        // If no matching key, add to end
-        i = this.records.length;
-      } else {
-        // If matching key, advance to appropriate position based on value (used in indexes)
-        while (i < this.records.length && cmp(this.records[i].key, newRecord.key) === 0) {
-          if (cmp(this.records[i].value, newRecord.value) !== -1) {
-            // Record value >= newRecord value, so insert here
-            break;
-          }
-          i += 1; // Look at next record
-        }
-      }
-    }
-    this.records.splice(i, 0, newRecord);
-  }
-  delete(key) {
-    const deletedRecords = [];
-    const isRange = key instanceof FDBKeyRange;
-    while (true) {
-      const idx = isRange ? getIndexByKeyRange(this.records, key) : getIndexByKey(this.records, key);
-      if (idx === -1) {
-        break;
-      }
-      deletedRecords.push(this.records[idx]);
-      this.records.splice(idx, 1);
-    }
-    return deletedRecords;
-  }
-  deleteByValue(key) {
-    const range = key instanceof FDBKeyRange ? key : FDBKeyRange.only(key);
-    const deletedRecords = [];
-    this.records = this.records.filter(record => {
-      const shouldDelete = range.includes(record.value);
-      if (shouldDelete) {
-        deletedRecords.push(record);
-      }
-      return !shouldDelete;
-    });
-    return deletedRecords;
-  }
-  clear() {
-    const deletedRecords = this.records.slice();
-    this.records = [];
-    return deletedRecords;
-  }
-  values(range, direction = "next") {
-    return {
-      [Symbol.iterator]: () => {
-        let i;
-        if (direction === "next") {
-          i = 0;
-          if (range !== undefined && range.lower !== undefined) {
-            while (this.records[i] !== undefined) {
-              const cmpResult = cmp(this.records[i].key, range.lower);
-              if (cmpResult === 1 || cmpResult === 0 && !range.lowerOpen) {
-                break;
-              }
-              i += 1;
-            }
-          }
-        } else {
-          i = this.records.length - 1;
-          if (range !== undefined && range.upper !== undefined) {
-            while (this.records[i] !== undefined) {
-              const cmpResult = cmp(this.records[i].key, range.upper);
-              if (cmpResult === -1 || cmpResult === 0 && !range.upperOpen) {
-                break;
-              }
-              i -= 1;
-            }
-          }
-        }
-        return {
-          next: () => {
-            let done;
-            let value;
-            if (direction === "next") {
-              value = this.records[i];
-              done = i >= this.records.length;
-              i += 1;
-              if (!done && range !== undefined && range.upper !== undefined) {
-                const cmpResult = cmp(value.key, range.upper);
-                done = cmpResult === 1 || cmpResult === 0 && range.upperOpen;
-                if (done) {
-                  value = undefined;
-                }
-              }
-            } else {
-              value = this.records[i];
-              done = i < 0;
-              i -= 1;
-              if (!done && range !== undefined && range.lower !== undefined) {
-                const cmpResult = cmp(value.key, range.lower);
-                done = cmpResult === -1 || cmpResult === 0 && range.lowerOpen;
-                if (done) {
-                  value = undefined;
-                }
-              }
-            }
-
-            // The weird "as IteratorResult<Record>" is needed because of
-            // https://github.com/Microsoft/TypeScript/issues/11375 and
-            // https://github.com/Microsoft/TypeScript/issues/2983
-            return {
-              done,
-              value
-            };
-          }
-        };
-      }
-    };
-  }
-}
-export default RecordStore;