nolo-cli 0.108.0-alpha.2 → 0.108.0

package/node_modules/browser-level/iterator.js

@@ -0,0 +1,239 @@
+'use strict'
+
+const { AbstractIterator } = require('abstract-level')
+const createKeyRange = require('./util/key-range')
+const deserialize = require('./util/deserialize')
+
+const kCache = Symbol('cache')
+const kFinished = Symbol('finished')
+const kOptions = Symbol('options')
+const kCurrentOptions = Symbol('currentOptions')
+const kPosition = Symbol('position')
+const kLocation = Symbol('location')
+const kFirst = Symbol('first')
+const emptyOptions = {}
+
+class Iterator extends AbstractIterator {
+  constructor (db, location, options) {
+    super(db, options)
+
+    this[kCache] = []
+    this[kFinished] = this.limit === 0
+    this[kOptions] = options
+    this[kCurrentOptions] = { ...options }
+    this[kPosition] = undefined
+    this[kLocation] = location
+    this[kFirst] = true
+  }
+
+  // Note: if called by _all() then size can be Infinity. This is an internal
+  // detail; by design AbstractIterator.nextv() does not support Infinity.
+  async _nextv (size, options) {
+    this[kFirst] = false
+
+    if (this[kFinished]) {
+      return []
+    }
+
+    if (this[kCache].length > 0) {
+      // TODO: mixing next and nextv is not covered by test suite
+      size = Math.min(size, this[kCache].length)
+      return this[kCache].splice(0, size)
+    }
+
+    // Adjust range by what we already visited
+    if (this[kPosition] !== undefined) {
+      if (this[kOptions].reverse) {
+        this[kCurrentOptions].lt = this[kPosition]
+        this[kCurrentOptions].lte = undefined
+      } else {
+        this[kCurrentOptions].gt = this[kPosition]
+        this[kCurrentOptions].gte = undefined
+      }
+    }
+
+    let keyRange
+
+    try {
+      keyRange = createKeyRange(this[kCurrentOptions])
+    } catch (_) {
+      // The lower key is greater than the upper key.
+      // IndexedDB throws an error, but we'll just return 0 results.
+      this[kFinished] = true
+      return []
+    }
+
+    const transaction = this.db.db.transaction([this[kLocation]], 'readonly')
+    const store = transaction.objectStore(this[kLocation])
+    const entries = []
+
+    const promise = new Promise(function (resolve, reject) {
+      // If an error occurs (on the request), the transaction will abort.
+      transaction.onabort = () => {
+        reject(transaction.error || new Error('aborted by user'))
+      }
+
+      transaction.oncomplete = () => {
+        resolve(entries)
+      }
+    })
+
+    if (!this[kOptions].reverse) {
+      let keys
+      let values
+
+      const complete = () => {
+        // Wait for both requests to complete
+        if (keys === undefined || values === undefined) return
+
+        const length = Math.max(keys.length, values.length)
+
+        if (length === 0 || size === Infinity) {
+          this[kFinished] = true
+        } else {
+          this[kPosition] = keys[length - 1]
+        }
+
+        // Resize
+        entries.length = length
+
+        // Merge keys and values
+        for (let i = 0; i < length; i++) {
+          const key = keys[i]
+          const value = values[i]
+
+          entries[i] = [
+            this[kOptions].keys ? deserialize(key) : undefined,
+            this[kOptions].values ? deserialize(value) : undefined
+          ]
+        }
+
+        maybeCommit(transaction)
+      }
+
+      // If keys were not requested and size is Infinity, we don't have to keep
+      // track of position and can thus skip getting keys.
+      if (this[kOptions].keys || size < Infinity) {
+        store.getAllKeys(keyRange, size < Infinity ? size : undefined).onsuccess = (ev) => {
+          keys = ev.target.result
+          complete()
+        }
+      } else {
+        keys = []
+        complete()
+      }
+
+      if (this[kOptions].values) {
+        store.getAll(keyRange, size < Infinity ? size : undefined).onsuccess = (ev) => {
+          values = ev.target.result
+          complete()
+        }
+      } else {
+        values = []
+        complete()
+      }
+    } else {
+      // Can't use getAll() in reverse, so use a slower cursor that yields one item at a time
+      // TODO: test if all target browsers support openKeyCursor
+      const method = !this[kOptions].values && store.openKeyCursor ? 'openKeyCursor' : 'openCursor'
+
+      store[method](keyRange, 'prev').onsuccess = (ev) => {
+        const cursor = ev.target.result
+
+        if (cursor) {
+          const { key, value } = cursor
+          this[kPosition] = key
+
+          entries.push([
+            this[kOptions].keys && key !== undefined ? deserialize(key) : undefined,
+            this[kOptions].values && value !== undefined ? deserialize(value) : undefined
+          ])
+
+          if (entries.length < size) {
+            cursor.continue()
+          } else {
+            maybeCommit(transaction)
+          }
+        } else {
+          this[kFinished] = true
+        }
+      }
+    }
+
+    return promise
+  }
+
+  async _next () {
+    if (this[kCache].length > 0) {
+      return this[kCache].shift()
+    }
+
+    if (!this[kFinished]) {
+      let size = Math.min(100, this.limit - this.count)
+
+      if (this[kFirst]) {
+        // It's common to only want one entry initially or after a seek()
+        this[kFirst] = false
+        size = 1
+      }
+
+      this[kCache] = await this._nextv(size, emptyOptions)
+
+      // Shift returns undefined if empty, which is what we want
+      return this[kCache].shift()
+    }
+  }
+
+  async _all (options) {
+    this[kFirst] = false
+
+    // TODO: mixing next and all is not covered by test suite
+    const cache = this[kCache].splice(0, this[kCache].length)
+    const size = this.limit - this.count - cache.length
+
+    if (size <= 0) {
+      return cache
+    }
+
+    let entries = await this._nextv(size, emptyOptions)
+    if (cache.length > 0) entries = cache.concat(entries)
+
+    return entries
+  }
+
+  _seek (target, options) {
+    this[kFirst] = true
+    this[kCache] = []
+    this[kFinished] = false
+    this[kPosition] = undefined
+
+    // TODO: not covered by test suite
+    this[kCurrentOptions] = { ...this[kOptions] }
+
+    let keyRange
+
+    try {
+      keyRange = createKeyRange(this[kOptions])
+    } catch (_) {
+      this[kFinished] = true
+      return
+    }
+
+    if (keyRange !== null && !keyRange.includes(target)) {
+      this[kFinished] = true
+    } else if (this[kOptions].reverse) {
+      this[kCurrentOptions].lte = target
+    } else {
+      this[kCurrentOptions].gte = target
+    }
+  }
+}
+
+exports.Iterator = Iterator
+
+function maybeCommit (transaction) {
+  // Commit (meaning close) now instead of waiting for auto-commit
+  if (typeof transaction.commit === 'function') {
+    transaction.commit()
+  }
+}

package/node_modules/browser-level/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "browser-level",
+  "version": "3.0.0",
+  "description": "An abstract-level database for browsers, backed by IndexedDB",
+  "author": "max ogden",
+  "license": "MIT",
+  "main": "index.js",
+  "types": "./index.d.ts",
+  "scripts": {
+    "test": "standard && hallmark && airtap --coverage test/index.js && nyc report",
+    "coverage": "nyc report -r lcovonly"
+  },
+  "files": [
+    "index.js",
+    "index.d.ts",
+    "iterator.js",
+    "util",
+    "CHANGELOG.md",
+    "UPGRADING.md"
+  ],
+  "dependencies": {
+    "abstract-level": "^3.1.0"
+  },
+  "devDependencies": {
+    "@babel/preset-env": "^7.26.9",
+    "@voxpelli/tsconfig": "^15.1.2",
+    "airtap": "^5.0.0",
+    "airtap-playwright": "^1.0.1",
+    "babelify": "^10.0.0",
+    "hallmark": "^5.0.1",
+    "nyc": "^17.1.0",
+    "standard": "^17.0.0",
+    "tape": "^5.5.2",
+    "typescript": "^5.8.3",
+    "uuid": "^11.1.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/Level/browser-level.git"
+  },
+  "homepage": "https://github.com/Level/browser-level",
+  "keywords": [
+    "level",
+    "leveldb",
+    "indexeddb",
+    "abstract-level"
+  ]
+}

package/node_modules/browser-level/util/clear.js

@@ -0,0 +1,38 @@
+'use strict'
+
+module.exports = async function clear (db, location, keyRange, options) {
+  if (options.limit === 0) return
+
+  const transaction = db.db.transaction([location], 'readwrite')
+  const store = transaction.objectStore(location)
+
+  let count = 0
+
+  const promise = new Promise(function (resolve, reject) {
+    transaction.oncomplete = resolve
+
+    transaction.onabort = function () {
+      reject(transaction.error || new Error('aborted by user'))
+    }
+  })
+
+  // A key cursor is faster (skips reading values) but not supported by IE
+  // TODO: we no longer support IE. Test others
+  const method = store.openKeyCursor ? 'openKeyCursor' : 'openCursor'
+  const direction = options.reverse ? 'prev' : 'next'
+
+  store[method](keyRange, direction).onsuccess = function (ev) {
+    const cursor = ev.target.result
+
+    if (cursor) {
+      // Wait for a request to complete before continuing, saving CPU.
+      store.delete(cursor.key).onsuccess = function () {
+        if (options.limit <= 0 || ++count < options.limit) {
+          cursor.continue()
+        }
+      }
+    }
+  }
+
+  return promise
+}

package/node_modules/browser-level/util/deserialize.js

@@ -0,0 +1,17 @@
+'use strict'
+
+const textEncoder = new TextEncoder()
+
+module.exports = function (data) {
+  if (data === undefined) {
+    // Undefined means not found in both IndexedDB and AbstractLevel
+    return data
+  } else if (data instanceof Uint8Array) {
+    return data
+  } else if (data instanceof ArrayBuffer) {
+    return new Uint8Array(data)
+  } else {
+    // Non-binary data stored with an old version (level-js < 5.0.0)
+    return textEncoder.encode(data)
+  }
+}

package/node_modules/browser-level/util/key-range.js

@@ -0,0 +1,20 @@
+/* global IDBKeyRange */
+
+'use strict'
+
+module.exports = function createKeyRange (options) {
+  const lower = options.gte !== undefined ? options.gte : options.gt !== undefined ? options.gt : undefined
+  const upper = options.lte !== undefined ? options.lte : options.lt !== undefined ? options.lt : undefined
+  const lowerExclusive = options.gte === undefined
+  const upperExclusive = options.lte === undefined
+
+  if (lower !== undefined && upper !== undefined) {
+    return IDBKeyRange.bound(lower, upper, lowerExclusive, upperExclusive)
+  } else if (lower !== undefined) {
+    return IDBKeyRange.lowerBound(lower, lowerExclusive)
+  } else if (upper !== undefined) {
+    return IDBKeyRange.upperBound(upper, upperExclusive)
+  } else {
+    return null
+  }
+}

package/node_modules/buffer/AUTHORS.md

@@ -0,0 +1,73 @@
+# Authors
+
+#### Ordered by first contribution.
+
+- Romain Beauxis (toots@rastageeks.org)
+- Tobias Koppers (tobias.koppers@googlemail.com)
+- Janus (ysangkok@gmail.com)
+- Rainer Dreyer (rdrey1@gmail.com)
+- Tõnis Tiigi (tonistiigi@gmail.com)
+- James Halliday (mail@substack.net)
+- Michael Williamson (mike@zwobble.org)
+- elliottcable (github@elliottcable.name)
+- rafael (rvalle@livelens.net)
+- Andrew Kelley (superjoe30@gmail.com)
+- Andreas Madsen (amwebdk@gmail.com)
+- Mike Brevoort (mike.brevoort@pearson.com)
+- Brian White (mscdex@mscdex.net)
+- Feross Aboukhadijeh (feross@feross.org)
+- Ruben Verborgh (ruben@verborgh.org)
+- eliang (eliang.cs@gmail.com)
+- Jesse Tane (jesse.tane@gmail.com)
+- Alfonso Boza (alfonso@cloud.com)
+- Mathias Buus (mathiasbuus@gmail.com)
+- Devon Govett (devongovett@gmail.com)
+- Daniel Cousens (github@dcousens.com)
+- Joseph Dykstra (josephdykstra@gmail.com)
+- Parsha Pourkhomami (parshap+git@gmail.com)
+- Damjan Košir (damjan.kosir@gmail.com)
+- daverayment (dave.rayment@gmail.com)
+- kawanet (u-suke@kawa.net)
+- Linus Unnebäck (linus@folkdatorn.se)
+- Nolan Lawson (nolan.lawson@gmail.com)
+- Calvin Metcalf (calvin.metcalf@gmail.com)
+- Koki Takahashi (hakatasiloving@gmail.com)
+- Guy Bedford (guybedford@gmail.com)
+- Jan Schär (jscissr@gmail.com)
+- RaulTsc (tomescu.raul@gmail.com)
+- Matthieu Monsch (monsch@alum.mit.edu)
+- Dan Ehrenberg (littledan@chromium.org)
+- Kirill Fomichev (fanatid@ya.ru)
+- Yusuke Kawasaki (u-suke@kawa.net)
+- DC (dcposch@dcpos.ch)
+- John-David Dalton (john.david.dalton@gmail.com)
+- adventure-yunfei (adventure030@gmail.com)
+- Emil Bay (github@tixz.dk)
+- Sam Sudar (sudar.sam@gmail.com)
+- Volker Mische (volker.mische@gmail.com)
+- David Walton (support@geekstocks.com)
+- Сковорода Никита Андреевич (chalkerx@gmail.com)
+- greenkeeper[bot] (greenkeeper[bot]@users.noreply.github.com)
+- ukstv (sergey.ukustov@machinomy.com)
+- Renée Kooi (renee@kooi.me)
+- ranbochen (ranbochen@qq.com)
+- Vladimir Borovik (bobahbdb@gmail.com)
+- greenkeeper[bot] (23040076+greenkeeper[bot]@users.noreply.github.com)
+- kumavis (aaron@kumavis.me)
+- Sergey Ukustov (sergey.ukustov@machinomy.com)
+- Fei Liu (liu.feiwood@gmail.com)
+- Blaine Bublitz (blaine.bublitz@gmail.com)
+- clement (clement@seald.io)
+- Koushik Dutta (koushd@gmail.com)
+- Jordan Harband (ljharb@gmail.com)
+- Niklas Mischkulnig (mischnic@users.noreply.github.com)
+- Nikolai Vavilov (vvnicholas@gmail.com)
+- Fedor Nezhivoi (gyzerok@users.noreply.github.com)
+- shuse2 (shus.toda@gmail.com)
+- Peter Newman (peternewman@users.noreply.github.com)
+- mathmakgakpak (44949126+mathmakgakpak@users.noreply.github.com)
+- jkkang (jkkang@smartauth.kr)
+- Deklan Webster (deklanw@gmail.com)
+- Martin Heidegger (martin.heidegger@gmail.com)
+
+#### Generated by bin/update-authors.sh.

package/node_modules/buffer/LICENSE

@@ -0,0 +1,21 @@
+The MIT License (MIT)
+
+Copyright (c) Feross Aboukhadijeh, and other contributors.
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in
+all copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
+THE SOFTWARE.