@highstate/designer 0.4.5 → 0.4.6

package/.output/server/node_modules/level-supports/index.js

@@ -1,26 +0,0 @@
-'use strict'
-
-exports.supports = function supports (...manifests) {
-  const manifest = manifests.reduce((acc, m) => Object.assign(acc, m), {})
-
-  // Snapshots is an alias for backwards compatibility
-  const implicitSnapshots = manifest.implicitSnapshots || manifest.snapshots || false
-  const explicitSnapshots = manifest.explicitSnapshots || false
-
-  return Object.assign(manifest, {
-    implicitSnapshots,
-    explicitSnapshots,
-    snapshots: implicitSnapshots,
-    has: manifest.has || false,
-    permanence: manifest.permanence || false,
-    seek: manifest.seek || false,
-    createIfMissing: manifest.createIfMissing || false,
-    errorIfExists: manifest.errorIfExists || false,
-    deferredOpen: manifest.deferredOpen || false,
-    streams: manifest.streams || false,
-    encodings: Object.assign({}, manifest.encodings),
-    events: Object.assign({}, manifest.events),
-    additionalMethods: Object.assign({}, manifest.additionalMethods),
-    signals: Object.assign({}, manifest.signals)
-  })
-}

package/.output/server/node_modules/level-supports/package.json

@@ -1,46 +0,0 @@
-{
-  "name": "level-supports",
-  "version": "6.2.0",
-  "description": "Create a manifest describing the abilities of an abstract-level database",
-  "license": "MIT",
-  "scripts": {
-    "test": "standard && hallmark && (nyc -s node test/self.js | tap-arc) && nyc report",
-    "test-pessimistic": "node test/self.js | tap-arc -pv",
-    "test-browsers-local": "airtap --coverage test/self.js && nyc report",
-    "coverage": "nyc report -r lcovonly",
-    "hallmark": "hallmark --fix"
-  },
-  "types": "./index.d.ts",
-  "files": [
-    "test",
-    "CHANGELOG.md",
-    "index.js",
-    "index.d.ts"
-  ],
-  "devDependencies": {
-    "@voxpelli/tsconfig": "^4.0.0",
-    "airtap": "^4.0.4",
-    "airtap-playwright": "^1.0.1",
-    "hallmark": "^4.0.0",
-    "nyc": "^15.1.0",
-    "standard": "^17.0.0",
-    "tap-arc": "^1.2.2",
-    "tape": "^5.4.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/Level/supports.git"
-  },
-  "homepage": "https://github.com/Level/supports",
-  "keywords": [
-    "abstract-leveldown",
-    "database",
-    "db",
-    "level",
-    "levelup",
-    "manifest"
-  ],
-  "engines": {
-    "node": ">=16"
-  }
-}

package/.output/server/node_modules/level-transcoder/index.js

@@ -1,158 +0,0 @@
-'use strict'
-
-const ModuleError = require('module-error')
-const encodings = require('./lib/encodings')
-const { Encoding } = require('./lib/encoding')
-const { BufferFormat, ViewFormat, UTF8Format } = require('./lib/formats')
-
-const kFormats = Symbol('formats')
-const kEncodings = Symbol('encodings')
-const validFormats = new Set(['buffer', 'view', 'utf8'])
-
-/** @template T */
-class Transcoder {
-  /**
-   * @param {Array<'buffer'|'view'|'utf8'>} formats
-   */
-  constructor (formats) {
-    if (!Array.isArray(formats)) {
-      throw new TypeError("The first argument 'formats' must be an array")
-    } else if (!formats.every(f => validFormats.has(f))) {
-      // Note: we only only support aliases in key- and valueEncoding options (where we already did)
-      throw new TypeError("Format must be one of 'buffer', 'view', 'utf8'")
-    }
-
-    /** @type {Map<string|MixedEncoding<any, any, any>, Encoding<any, any, any>>} */
-    this[kEncodings] = new Map()
-    this[kFormats] = new Set(formats)
-
-    // Register encodings (done early in order to populate encodings())
-    for (const k in encodings) {
-      try {
-        this.encoding(k)
-      } catch (err) {
-        /* istanbul ignore if: assertion */
-        if (err.code !== 'LEVEL_ENCODING_NOT_SUPPORTED') throw err
-      }
-    }
-  }
-
-  /**
-   * @returns {Array<Encoding<any,T,any>>}
-   */
-  encodings () {
-    return Array.from(new Set(this[kEncodings].values()))
-  }
-
-  /**
-   * @param {string|MixedEncoding<any, any, any>} encoding
-   * @returns {Encoding<any, T, any>}
-   */
-  encoding (encoding) {
-    let resolved = this[kEncodings].get(encoding)
-
-    if (resolved === undefined) {
-      if (typeof encoding === 'string' && encoding !== '') {
-        resolved = lookup[encoding]
-
-        if (!resolved) {
-          throw new ModuleError(`Encoding '${encoding}' is not found`, {
-            code: 'LEVEL_ENCODING_NOT_FOUND'
-          })
-        }
-      } else if (typeof encoding !== 'object' || encoding === null) {
-        throw new TypeError("First argument 'encoding' must be a string or object")
-      } else {
-        resolved = from(encoding)
-      }
-
-      const { name, format } = resolved
-
-      if (!this[kFormats].has(format)) {
-        if (this[kFormats].has('view')) {
-          resolved = resolved.createViewTranscoder()
-        } else if (this[kFormats].has('buffer')) {
-          resolved = resolved.createBufferTranscoder()
-        } else if (this[kFormats].has('utf8')) {
-          resolved = resolved.createUTF8Transcoder()
-        } else {
-          throw new ModuleError(`Encoding '${name}' cannot be transcoded`, {
-            code: 'LEVEL_ENCODING_NOT_SUPPORTED'
-          })
-        }
-      }
-
-      for (const k of [encoding, name, resolved.name, resolved.commonName]) {
-        this[kEncodings].set(k, resolved)
-      }
-    }
-
-    return resolved
-  }
-}
-
-exports.Transcoder = Transcoder
-
-/**
- * @param {MixedEncoding<any, any, any>} options
- * @returns {Encoding<any, any, any>}
- */
-function from (options) {
-  if (options instanceof Encoding) {
-    return options
-  }
-
-  // Loosely typed for ecosystem compatibility
-  const maybeType = 'type' in options && typeof options.type === 'string' ? options.type : undefined
-  const name = options.name || maybeType || `anonymous-${anonymousCount++}`
-
-  switch (detectFormat(options)) {
-    case 'view': return new ViewFormat({ ...options, name })
-    case 'utf8': return new UTF8Format({ ...options, name })
-    case 'buffer': return new BufferFormat({ ...options, name })
-    default: {
-      throw new TypeError("Format must be one of 'buffer', 'view', 'utf8'")
-    }
-  }
-}
-
-/**
- * If format is not provided, fallback to detecting `level-codec`
- * or `multiformats` encodings, else assume a format of buffer.
- * @param {MixedEncoding<any, any, any>} options
- * @returns {string}
- */
-function detectFormat (options) {
-  if ('format' in options && options.format !== undefined) {
-    return options.format
-  } else if ('buffer' in options && typeof options.buffer === 'boolean') {
-    return options.buffer ? 'buffer' : 'utf8' // level-codec
-  } else if ('code' in options && Number.isInteger(options.code)) {
-    return 'view' // multiformats
-  } else {
-    return 'buffer'
-  }
-}
-
-/**
- * @typedef {import('./lib/encoding').MixedEncoding<TIn,TFormat,TOut>} MixedEncoding
- * @template TIn, TFormat, TOut
- */
-
-/**
- * @type {Object.<string, Encoding<any, any, any>>}
- */
-const aliases = {
-  binary: encodings.buffer,
-  'utf-8': encodings.utf8
-}
-
-/**
- * @type {Object.<string, Encoding<any, any, any>>}
- */
-const lookup = {
-  ...encodings,
-  ...aliases
-}
-
-let anonymousCount = 0

package/.output/server/node_modules/level-transcoder/lib/encoding.js

@@ -1,105 +0,0 @@
-'use strict'
-
-const ModuleError = require('module-error')
-const formats = new Set(['buffer', 'view', 'utf8'])
-
-/**
- * @template TIn, TFormat, TOut
- * @abstract
- */
-class Encoding {
-  /**
-   * @param {IEncoding<TIn,TFormat,TOut>} options
-   */
-  constructor (options) {
-    /** @type {(data: TIn) => TFormat} */
-    this.encode = options.encode || this.encode
-
-    /** @type {(data: TFormat) => TOut} */
-    this.decode = options.decode || this.decode
-
-    /** @type {string} */
-    this.name = options.name || this.name
-
-    /** @type {string} */
-    this.format = options.format || this.format
-
-    if (typeof this.encode !== 'function') {
-      throw new TypeError("The 'encode' property must be a function")
-    }
-
-    if (typeof this.decode !== 'function') {
-      throw new TypeError("The 'decode' property must be a function")
-    }
-
-    this.encode = this.encode.bind(this)
-    this.decode = this.decode.bind(this)
-
-    if (typeof this.name !== 'string' || this.name === '') {
-      throw new TypeError("The 'name' property must be a string")
-    }
-
-    if (typeof this.format !== 'string' || !formats.has(this.format)) {
-      throw new TypeError("The 'format' property must be one of 'buffer', 'view', 'utf8'")
-    }
-
-    if (options.createViewTranscoder) {
-      this.createViewTranscoder = options.createViewTranscoder
-    }
-
-    if (options.createBufferTranscoder) {
-      this.createBufferTranscoder = options.createBufferTranscoder
-    }
-
-    if (options.createUTF8Transcoder) {
-      this.createUTF8Transcoder = options.createUTF8Transcoder
-    }
-  }
-
-  get commonName () {
-    return /** @type {string} */ (this.name.split('+')[0])
-  }
-
-  /** @return {BufferFormat<TIn,TOut>} */
-  createBufferTranscoder () {
-    throw new ModuleError(`Encoding '${this.name}' cannot be transcoded to 'buffer'`, {
-      code: 'LEVEL_ENCODING_NOT_SUPPORTED'
-    })
-  }
-
-  /** @return {ViewFormat<TIn,TOut>} */
-  createViewTranscoder () {
-    throw new ModuleError(`Encoding '${this.name}' cannot be transcoded to 'view'`, {
-      code: 'LEVEL_ENCODING_NOT_SUPPORTED'
-    })
-  }
-
-  /** @return {UTF8Format<TIn,TOut>} */
-  createUTF8Transcoder () {
-    throw new ModuleError(`Encoding '${this.name}' cannot be transcoded to 'utf8'`, {
-      code: 'LEVEL_ENCODING_NOT_SUPPORTED'
-    })
-  }
-}
-
-exports.Encoding = Encoding
-
-/**
- * @typedef {import('./encoding').IEncoding<TIn,TFormat,TOut>} IEncoding
- * @template TIn, TFormat, TOut
- */
-
-/**
- * @typedef {import('./formats').BufferFormat<TIn,TOut>} BufferFormat
- * @template TIn, TOut
- */
-
-/**
- * @typedef {import('./formats').ViewFormat<TIn,TOut>} ViewFormat
- * @template TIn, TOut
- */
-
-/**
- * @typedef {import('./formats').UTF8Format<TIn,TOut>} UTF8Format
- * @template TIn, TOut
- */

package/.output/server/node_modules/level-transcoder/lib/encodings.js

@@ -1,135 +0,0 @@
-'use strict'
-
-const { Buffer } = require('buffer') || { Buffer: { isBuffer: () => false } }
-const { textEncoder, textDecoder } = require('./text-endec')()
-const { BufferFormat, ViewFormat, UTF8Format } = require('./formats')
-
-/** @type {<T>(v: T) => v} */
-const identity = (v) => v
-
-/**
- * @type {typeof import('./encodings').utf8}
- */
-exports.utf8 = new UTF8Format({
-  encode: function (data) {
-    // On node 16.9.1 buffer.toString() is 5x faster than TextDecoder
-    return Buffer.isBuffer(data)
-      ? data.toString('utf8')
-      : ArrayBuffer.isView(data)
-        ? textDecoder.decode(data)
-        : String(data)
-  },
-  decode: identity,
-  name: 'utf8',
-  createViewTranscoder () {
-    return new ViewFormat({
-      encode: function (data) {
-        return ArrayBuffer.isView(data) ? data : textEncoder.encode(data)
-      },
-      decode: function (data) {
-        return textDecoder.decode(data)
-      },
-      name: `${this.name}+view`
-    })
-  },
-  createBufferTranscoder () {
-    return new BufferFormat({
-      encode: function (data) {
-        return Buffer.isBuffer(data)
-          ? data
-          : ArrayBuffer.isView(data)
-            ? Buffer.from(data.buffer, data.byteOffset, data.byteLength)
-            : Buffer.from(String(data), 'utf8')
-      },
-      decode: function (data) {
-        return data.toString('utf8')
-      },
-      name: `${this.name}+buffer`
-    })
-  }
-})
-
-/**
- * @type {typeof import('./encodings').json}
- */
-exports.json = new UTF8Format({
-  encode: JSON.stringify,
-  decode: JSON.parse,
-  name: 'json'
-})
-
-/**
- * @type {typeof import('./encodings').buffer}
- */
-exports.buffer = new BufferFormat({
-  encode: function (data) {
-    return Buffer.isBuffer(data)
-      ? data
-      : ArrayBuffer.isView(data)
-        ? Buffer.from(data.buffer, data.byteOffset, data.byteLength)
-        : Buffer.from(String(data), 'utf8')
-  },
-  decode: identity,
-  name: 'buffer',
-  createViewTranscoder () {
-    return new ViewFormat({
-      encode: function (data) {
-        return ArrayBuffer.isView(data) ? data : Buffer.from(String(data), 'utf8')
-      },
-      decode: function (data) {
-        return Buffer.from(data.buffer, data.byteOffset, data.byteLength)
-      },
-      name: `${this.name}+view`
-    })
-  }
-})
-
-/**
- * @type {typeof import('./encodings').view}
- */
-exports.view = new ViewFormat({
-  encode: function (data) {
-    return ArrayBuffer.isView(data) ? data : textEncoder.encode(data)
-  },
-  decode: identity,
-  name: 'view',
-  createBufferTranscoder () {
-    return new BufferFormat({
-      encode: function (data) {
-        return Buffer.isBuffer(data)
-          ? data
-          : ArrayBuffer.isView(data)
-            ? Buffer.from(data.buffer, data.byteOffset, data.byteLength)
-            : Buffer.from(String(data), 'utf8')
-      },
-      decode: identity,
-      name: `${this.name}+buffer`
-    })
-  }
-})
-
-/**
- * @type {typeof import('./encodings').hex}
- */
-exports.hex = new BufferFormat({
-  encode: function (data) {
-    return Buffer.isBuffer(data) ? data : Buffer.from(String(data), 'hex')
-  },
-  decode: function (buffer) {
-    return buffer.toString('hex')
-  },
-  name: 'hex'
-})
-
-/**
- * @type {typeof import('./encodings').base64}
- */
-exports.base64 = new BufferFormat({
-  encode: function (data) {
-    return Buffer.isBuffer(data) ? data : Buffer.from(String(data), 'base64')
-  },
-  decode: function (buffer) {
-    return buffer.toString('base64')
-  },
-  name: 'base64'
-})

package/.output/server/node_modules/level-transcoder/lib/formats.js

@@ -1,111 +0,0 @@
-'use strict'
-
-const { Buffer } = require('buffer') || {}
-const { Encoding } = require('./encoding')
-const textEndec = require('./text-endec')
-
-/**
- * @template TIn, TOut
- * @extends {Encoding<TIn,Buffer,TOut>}
- */
-class BufferFormat extends Encoding {
-  /**
-   * @param {Omit<IEncoding<TIn, Buffer, TOut>, 'format'>} options
-   */
-  constructor (options) {
-    super({ ...options, format: 'buffer' })
-  }
-
-  /** @override */
-  createViewTranscoder () {
-    return new ViewFormat({
-      encode: this.encode, // Buffer is a view (UInt8Array)
-      decode: (data) => this.decode(
-        Buffer.from(data.buffer, data.byteOffset, data.byteLength)
-      ),
-      name: `${this.name}+view`
-    })
-  }
-
-  /** @override */
-  createBufferTranscoder () {
-    return this
-  }
-}
-
-/**
- * @extends {Encoding<TIn,Uint8Array,TOut>}
- * @template TIn, TOut
- */
-class ViewFormat extends Encoding {
-  /**
-   * @param {Omit<IEncoding<TIn, Uint8Array, TOut>, 'format'>} options
-   */
-  constructor (options) {
-    super({ ...options, format: 'view' })
-  }
-
-  /** @override */
-  createBufferTranscoder () {
-    return new BufferFormat({
-      encode: (data) => {
-        const view = this.encode(data)
-        return Buffer.from(view.buffer, view.byteOffset, view.byteLength)
-      },
-      decode: this.decode, // Buffer is a view (UInt8Array)
-      name: `${this.name}+buffer`
-    })
-  }
-
-  /** @override */
-  createViewTranscoder () {
-    return this
-  }
-}
-
-/**
- * @extends {Encoding<TIn,string,TOut>}
- * @template TIn, TOut
- */
-class UTF8Format extends Encoding {
-  /**
-   * @param {Omit<IEncoding<TIn, string, TOut>, 'format'>} options
-   */
-  constructor (options) {
-    super({ ...options, format: 'utf8' })
-  }
-
-  /** @override */
-  createBufferTranscoder () {
-    return new BufferFormat({
-      encode: (data) => Buffer.from(this.encode(data), 'utf8'),
-      decode: (data) => this.decode(data.toString('utf8')),
-      name: `${this.name}+buffer`
-    })
-  }
-
-  /** @override */
-  createViewTranscoder () {
-    const { textEncoder, textDecoder } = textEndec()
-
-    return new ViewFormat({
-      encode: (data) => textEncoder.encode(this.encode(data)),
-      decode: (data) => this.decode(textDecoder.decode(data)),
-      name: `${this.name}+view`
-    })
-  }
-
-  /** @override */
-  createUTF8Transcoder () {
-    return this
-  }
-}
-
-exports.BufferFormat = BufferFormat
-exports.ViewFormat = ViewFormat
-exports.UTF8Format = UTF8Format
-
-/**
- * @typedef {import('./encoding').IEncoding<TIn,TFormat,TOut>} IEncoding
- * @template TIn, TFormat, TOut
- */

package/.output/server/node_modules/level-transcoder/lib/text-endec.js

@@ -1,19 +0,0 @@
-'use strict'
-
-/** @type {{ textEncoder: TextEncoder, textDecoder: TextDecoder }|null} */
-let lazy = null
-
-/**
- * Get semi-global instances of TextEncoder and TextDecoder.
- * @returns {{ textEncoder: TextEncoder, textDecoder: TextDecoder }}
- */
-module.exports = function () {
-  if (lazy === null) {
-    lazy = {
-      textEncoder: new TextEncoder(),
-      textDecoder: new TextDecoder()
-    }
-  }
-
-  return lazy
-}

package/.output/server/node_modules/level-transcoder/package.json

@@ -1,46 +0,0 @@
-{
-  "name": "level-transcoder",
-  "version": "1.0.1",
-  "description": "Encode data with built-in or custom encodings",
-  "license": "MIT",
-  "main": "index.js",
-  "types": "./index.d.ts",
-  "scripts": {
-    "test": "ts-standard && tsc && standard && hallmark && nyc tape test/*.js",
-    "test-browsers-local": "airtap --coverage --verbose test/*.js",
-    "coverage": "nyc report -r lcovonly",
-    "hallmark": "hallmark --fix"
-  },
-  "files": [
-    "lib",
-    "index.js",
-    "index.d.ts",
-    "CHANGELOG.md",
-    "LICENSE",
-    "UPGRADING.md"
-  ],
-  "dependencies": {
-    "buffer": "^6.0.3",
-    "module-error": "^1.0.1"
-  },
-  "devDependencies": {
-    "@types/node": "^16.11.10",
-    "@voxpelli/tsconfig": "^3.1.0",
-    "airtap": "^4.0.3",
-    "airtap-playwright": "^1.0.1",
-    "hallmark": "^4.0.0",
-    "nyc": "^15.1.0",
-    "standard": "^16.0.3",
-    "tape": "^5.3.2",
-    "ts-standard": "^11.0.0",
-    "typescript": "^4.5.2"
-  },
-  "repository": "Level/transcoder",
-  "homepage": "https://github.com/Level/transcoder",
-  "keywords": [
-    "level"
-  ],
-  "engines": {
-    "node": ">=12"
-  }
-}