wiki-plugin-allyabase 0.0.2 → 0.0.4

package/test/node_modules/fast-safe-stringify/test.js

@@ -1,397 +0,0 @@
-const test = require('tap').test
-const fss = require('./')
-const clone = require('clone')
-const s = JSON.stringify
-const stream = require('stream')
-
-test('circular reference to root', function (assert) {
-  const fixture = { name: 'Tywin Lannister' }
-  fixture.circle = fixture
-  const expected = s({ name: 'Tywin Lannister', circle: '[Circular]' })
-  const actual = fss(fixture)
-  assert.equal(actual, expected)
-  assert.end()
-})
-
-test('circular getter reference to root', function (assert) {
-  const fixture = {
-    name: 'Tywin Lannister',
-    get circle () {
-      return fixture
-    }
-  }
-  const expected = s({ name: 'Tywin Lannister', circle: '[Circular]' })
-  const actual = fss(fixture)
-  assert.equal(actual, expected)
-  assert.end()
-})
-
-test('nested circular reference to root', function (assert) {
-  const fixture = { name: 'Tywin Lannister' }
-  fixture.id = { circle: fixture }
-  const expected = s({ name: 'Tywin Lannister', id: { circle: '[Circular]' } })
-  const actual = fss(fixture)
-  assert.equal(actual, expected)
-  assert.end()
-})
-
-test('child circular reference', function (assert) {
-  const fixture = {
-    name: 'Tywin Lannister',
-    child: { name: 'Tyrion Lannister' }
-  }
-  fixture.child.dinklage = fixture.child
-  const expected = s({
-    name: 'Tywin Lannister',
-    child: {
-      name: 'Tyrion Lannister',
-      dinklage: '[Circular]'
-    }
-  })
-  const actual = fss(fixture)
-  assert.equal(actual, expected)
-  assert.end()
-})
-
-test('nested child circular reference', function (assert) {
-  const fixture = {
-    name: 'Tywin Lannister',
-    child: { name: 'Tyrion Lannister' }
-  }
-  fixture.child.actor = { dinklage: fixture.child }
-  const expected = s({
-    name: 'Tywin Lannister',
-    child: {
-      name: 'Tyrion Lannister',
-      actor: { dinklage: '[Circular]' }
-    }
-  })
-  const actual = fss(fixture)
-  assert.equal(actual, expected)
-  assert.end()
-})
-
-test('circular objects in an array', function (assert) {
-  const fixture = { name: 'Tywin Lannister' }
-  fixture.hand = [fixture, fixture]
-  const expected = s({
-    name: 'Tywin Lannister',
-    hand: ['[Circular]', '[Circular]']
-  })
-  const actual = fss(fixture)
-  assert.equal(actual, expected)
-  assert.end()
-})
-
-test('nested circular references in an array', function (assert) {
-  const fixture = {
-    name: 'Tywin Lannister',
-    offspring: [{ name: 'Tyrion Lannister' }, { name: 'Cersei Lannister' }]
-  }
-  fixture.offspring[0].dinklage = fixture.offspring[0]
-  fixture.offspring[1].headey = fixture.offspring[1]
-
-  const expected = s({
-    name: 'Tywin Lannister',
-    offspring: [
-      { name: 'Tyrion Lannister', dinklage: '[Circular]' },
-      { name: 'Cersei Lannister', headey: '[Circular]' }
-    ]
-  })
-  const actual = fss(fixture)
-  assert.equal(actual, expected)
-  assert.end()
-})
-
-test('circular arrays', function (assert) {
-  const fixture = []
-  fixture.push(fixture, fixture)
-  const expected = s(['[Circular]', '[Circular]'])
-  const actual = fss(fixture)
-  assert.equal(actual, expected)
-  assert.end()
-})
-
-test('nested circular arrays', function (assert) {
-  const fixture = []
-  fixture.push(
-    { name: 'Jon Snow', bastards: fixture },
-    { name: 'Ramsay Bolton', bastards: fixture }
-  )
-  const expected = s([
-    { name: 'Jon Snow', bastards: '[Circular]' },
-    { name: 'Ramsay Bolton', bastards: '[Circular]' }
-  ])
-  const actual = fss(fixture)
-  assert.equal(actual, expected)
-  assert.end()
-})
-
-test('repeated non-circular references in objects', function (assert) {
-  const daenerys = { name: 'Daenerys Targaryen' }
-  const fixture = {
-    motherOfDragons: daenerys,
-    queenOfMeereen: daenerys
-  }
-  const expected = s(fixture)
-  const actual = fss(fixture)
-  assert.equal(actual, expected)
-  assert.end()
-})
-
-test('repeated non-circular references in arrays', function (assert) {
-  const daenerys = { name: 'Daenerys Targaryen' }
-  const fixture = [daenerys, daenerys]
-  const expected = s(fixture)
-  const actual = fss(fixture)
-  assert.equal(actual, expected)
-  assert.end()
-})
-
-test('double child circular reference', function (assert) {
-  // create circular reference
-  const child = { name: 'Tyrion Lannister' }
-  child.dinklage = child
-
-  // include it twice in the fixture
-  const fixture = { name: 'Tywin Lannister', childA: child, childB: child }
-  const cloned = clone(fixture)
-  const expected = s({
-    name: 'Tywin Lannister',
-    childA: {
-      name: 'Tyrion Lannister',
-      dinklage: '[Circular]'
-    },
-    childB: {
-      name: 'Tyrion Lannister',
-      dinklage: '[Circular]'
-    }
-  })
-  const actual = fss(fixture)
-  assert.equal(actual, expected)
-
-  // check if the fixture has not been modified
-  assert.same(fixture, cloned)
-  assert.end()
-})
-
-test('child circular reference with toJSON', function (assert) {
-  // Create a test object that has an overridden `toJSON` property
-  TestObject.prototype.toJSON = function () {
-    return { special: 'case' }
-  }
-  function TestObject (content) {}
-
-  // Creating a simple circular object structure
-  const parentObject = {}
-  parentObject.childObject = new TestObject()
-  parentObject.childObject.parentObject = parentObject
-
-  // Creating a simple circular object structure
-  const otherParentObject = new TestObject()
-  otherParentObject.otherChildObject = {}
-  otherParentObject.otherChildObject.otherParentObject = otherParentObject
-
-  // Making sure our original tests work
-  assert.same(parentObject.childObject.parentObject, parentObject)
-  assert.same(
-    otherParentObject.otherChildObject.otherParentObject,
-    otherParentObject
-  )
-
-  // Should both be idempotent
-  assert.equal(fss(parentObject), '{"childObject":{"special":"case"}}')
-  assert.equal(fss(otherParentObject), '{"special":"case"}')
-
-  // Therefore the following assertion should be `true`
-  assert.same(parentObject.childObject.parentObject, parentObject)
-  assert.same(
-    otherParentObject.otherChildObject.otherParentObject,
-    otherParentObject
-  )
-
-  assert.end()
-})
-
-test('null object', function (assert) {
-  const expected = s(null)
-  const actual = fss(null)
-  assert.equal(actual, expected)
-  assert.end()
-})
-
-test('null property', function (assert) {
-  const expected = s({ f: null })
-  const actual = fss({ f: null })
-  assert.equal(actual, expected)
-  assert.end()
-})
-
-test('nested child circular reference in toJSON', function (assert) {
-  const circle = { some: 'data' }
-  circle.circle = circle
-  const a = {
-    b: {
-      toJSON: function () {
-        a.b = 2
-        return '[Redacted]'
-      }
-    },
-    baz: {
-      circle,
-      toJSON: function () {
-        a.baz = circle
-        return '[Redacted]'
-      }
-    }
-  }
-  const o = {
-    a,
-    bar: a
-  }
-
-  const expected = s({
-    a: {
-      b: '[Redacted]',
-      baz: '[Redacted]'
-    },
-    bar: {
-      b: 2,
-      baz: {
-        some: 'data',
-        circle: '[Circular]'
-      }
-    }
-  })
-  const actual = fss(o)
-  assert.equal(actual, expected)
-  assert.end()
-})
-
-test('circular getters are restored when stringified', function (assert) {
-  const fixture = {
-    name: 'Tywin Lannister',
-    get circle () {
-      return fixture
-    }
-  }
-  fss(fixture)
-
-  assert.equal(fixture.circle, fixture)
-  assert.end()
-})
-
-test('non-configurable circular getters use a replacer instead of markers', function (assert) {
-  const fixture = { name: 'Tywin Lannister' }
-  Object.defineProperty(fixture, 'circle', {
-    configurable: false,
-    get: function () {
-      return fixture
-    },
-    enumerable: true
-  })
-
-  fss(fixture)
-
-  assert.equal(fixture.circle, fixture)
-  assert.end()
-})
-
-test('getter child circular reference are replaced instead of marked', function (assert) {
-  const fixture = {
-    name: 'Tywin Lannister',
-    child: {
-      name: 'Tyrion Lannister',
-      get dinklage () {
-        return fixture.child
-      }
-    },
-    get self () {
-      return fixture
-    }
-  }
-
-  const expected = s({
-    name: 'Tywin Lannister',
-    child: {
-      name: 'Tyrion Lannister',
-      dinklage: '[Circular]'
-    },
-    self: '[Circular]'
-  })
-  const actual = fss(fixture)
-  assert.equal(actual, expected)
-  assert.end()
-})
-
-test('Proxy throwing', function (assert) {
-  assert.plan(1)
-  const s = new stream.PassThrough()
-  s.resume()
-  s.write('', () => {
-    assert.end()
-  })
-  const actual = fss({ s, p: new Proxy({}, { get () { throw new Error('kaboom') } }) })
-  assert.equal(actual, '"[unable to serialize, circular reference is too complex to analyze]"')
-})
-
-test('depthLimit option - will replace deep objects', function (assert) {
-  const fixture = {
-    name: 'Tywin Lannister',
-    child: {
-      name: 'Tyrion Lannister'
-    },
-    get self () {
-      return fixture
-    }
-  }
-
-  const expected = s({
-    name: 'Tywin Lannister',
-    child: '[...]',
-    self: '[Circular]'
-  })
-  const actual = fss(fixture, undefined, undefined, {
-    depthLimit: 1,
-    edgesLimit: 1
-  })
-  assert.equal(actual, expected)
-  assert.end()
-})
-
-test('edgesLimit option - will replace deep objects', function (assert) {
-  const fixture = {
-    object: {
-      1: { test: 'test' },
-      2: { test: 'test' },
-      3: { test: 'test' },
-      4: { test: 'test' }
-    },
-    array: [
-      { test: 'test' },
-      { test: 'test' },
-      { test: 'test' },
-      { test: 'test' }
-    ],
-    get self () {
-      return fixture
-    }
-  }
-
-  const expected = s({
-    object: {
-      1: { test: 'test' },
-      2: { test: 'test' },
-      3: { test: 'test' },
-      4: '[...]'
-    },
-    array: [{ test: 'test' }, { test: 'test' }, { test: 'test' }, '[...]'],
-    self: '[Circular]'
-  })
-  const actual = fss(fixture, undefined, undefined, {
-    depthLimit: 3,
-    edgesLimit: 3
-  })
-  assert.equal(actual, expected)
-  assert.end()
-})

package/test/node_modules/fetch-blob/LICENSE

@@ -1,21 +0,0 @@
-MIT License
-
-Copyright (c) 2019 David Frank
-
-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.

package/test/node_modules/fetch-blob/README.md

@@ -1,106 +0,0 @@
-# fetch-blob
-
-[![npm version][npm-image]][npm-url]
-[![build status][ci-image]][ci-url]
-[![coverage status][codecov-image]][codecov-url]
-[![install size][install-size-image]][install-size-url]
-
-A Blob implementation in Node.js, originally from [node-fetch](https://github.com/node-fetch/node-fetch).
-
-## Installation
-
-```sh
-npm install fetch-blob
-```
-
-<details>
-  <summary>Upgrading from 2x to 3x</summary>
-
-  Updating from 2 to 3 should be a breeze since there is not many changes to the blob specification.
-  The major cause of a major release is coding standards.
-    - internal WeakMaps was replaced with private fields
-    - internal Buffer.from was replaced with TextEncoder/Decoder
-    - internal buffers was replaced with Uint8Arrays
-    - CommonJS was replaced with ESM
-    - The node stream returned by calling `blob.stream()` was replaced with whatwg streams
-    - (Read "Differences from other blobs" for more info.)
-
-</details>
-
-<details>
-  <summary>Differences from other Blobs</summary>
-
-  - Unlike NodeJS `buffer.Blob` (Added in: v15.7.0) and browser native Blob this polyfilled version can't be sent via PostMessage
-  - This blob version is more arbitrary, it can be constructed with blob parts that isn't a instance of itself
-  it has to look and behave as a blob to be accepted as a blob part.
-    - The benefit of this is that you can create other types of blobs that don't contain any internal data that has to be read in other ways, such as the `BlobDataItem` created in `from.js` that wraps a file path into a blob-like item and read lazily (nodejs plans to [implement this][fs-blobs] as well)
-  - The `blob.stream()` is the most noticeable differences. It returns a WHATWG stream now. to keep it as a node stream you would have to do:
-
-  ```js
-    import {Readable} from 'stream'
-    const stream = Readable.from(blob.stream())
-  ```
-</details>
-
-## Usage
-
-```js
-// Ways to import
-// (PS it's dependency free ESM package so regular http-import from CDN works too)
-import Blob from 'fetch-blob'
-import File from 'fetch-blob/file.js'
-
-import {Blob} from 'fetch-blob'
-import {File} from 'fetch-blob/file.js'
-
-const {Blob} = await import('fetch-blob')
-
-
-// Ways to read the blob:
-const blob = new Blob(['hello, world'])
-
-await blob.text()
-await blob.arrayBuffer()
-for await (let chunk of  blob.stream()) { ... }
-blob.stream().getReader().read()
-blob.stream().getReader({mode: 'byob'}).read(view)
-```
-
-### Blob part backed up by filesystem
-
-`fetch-blob/from.js` comes packed with tools to convert any filepath into either a Blob or a File
-It will not read the content into memory. It will only stat the file for last modified date and file size.
-
-```js
-// The default export is sync and use fs.stat to retrieve size & last modified as a blob
-import blobFromSync from 'fetch-blob/from.js'
-import {File, Blob, blobFrom, blobFromSync, fileFrom, fileFromSync} from 'fetch-blob/from.js'
-
-const fsFile = fileFromSync('./2-GiB-file.bin', 'application/octet-stream')
-const fsBlob = await blobFrom('./2-GiB-file.mp4')
-
-// Not a 4 GiB memory snapshot, just holds references
-// points to where data is located on the disk
-const blob = new Blob([fsFile, fsBlob, 'memory', new Uint8Array(10)])
-console.log(blob.size) // ~4 GiB
-```
-
-`blobFrom|blobFromSync|fileFrom|fileFromSync(path, [mimetype])`
-
-### Creating Blobs backed up by other async sources
-Our Blob & File class are more generic then any other polyfills in the way that it can accept any blob look-a-like item
-An example of this is that our blob implementation can be constructed with parts coming from [BlobDataItem](https://github.com/node-fetch/fetch-blob/blob/8ef89adad40d255a3bbd55cf38b88597c1cd5480/from.js#L32) (aka a filepath) or from [buffer.Blob](https://nodejs.org/api/buffer.html#buffer_new_buffer_blob_sources_options), It dose not have to implement all the methods - just enough that it can be read/understood by our Blob implementation. The minium requirements is that it has `Symbol.toStringTag`, `size`, `slice()` and either a `stream()` or a `arrayBuffer()` method. If you then wrap it in our Blob or File `new Blob([blobDataItem])` then you get all of the other methods that should be implemented in a blob or file
-
-An example of this could be to create a file or blob like item coming from a remote HTTP request. Or from a DataBase
-
-See the [MDN documentation](https://developer.mozilla.org/en-US/docs/Web/API/Blob) and [tests](https://github.com/node-fetch/fetch-blob/blob/master/test.js) for more details of how to use the Blob.
-
-[npm-image]: https://flat.badgen.net/npm/v/fetch-blob
-[npm-url]: https://www.npmjs.com/package/fetch-blob
-[ci-image]: https://github.com/node-fetch/fetch-blob/workflows/CI/badge.svg
-[ci-url]: https://github.com/node-fetch/fetch-blob/actions
-[codecov-image]: https://flat.badgen.net/codecov/c/github/node-fetch/fetch-blob/master
-[codecov-url]: https://codecov.io/gh/node-fetch/fetch-blob
-[install-size-image]: https://flat.badgen.net/packagephobia/install/fetch-blob
-[install-size-url]: https://packagephobia.now.sh/result?p=fetch-blob
-[fs-blobs]: https://github.com/nodejs/node/issues/37340

package/test/node_modules/fetch-blob/file.d.ts

@@ -1,2 +0,0 @@
-/** @type {typeof globalThis.File} */ export const File: typeof globalThis.File;
-export default File;

package/test/node_modules/fetch-blob/file.js

@@ -1,49 +0,0 @@
-import Blob from './index.js'
-
-const _File = class File extends Blob {
-  #lastModified = 0
-  #name = ''
-
-  /**
-   * @param {*[]} fileBits
-   * @param {string} fileName
-   * @param {{lastModified?: number, type?: string}} options
-   */// @ts-ignore
-  constructor (fileBits, fileName, options = {}) {
-    if (arguments.length < 2) {
-      throw new TypeError(`Failed to construct 'File': 2 arguments required, but only ${arguments.length} present.`)
-    }
-    super(fileBits, options)
-
-    if (options === null) options = {}
-
-    // Simulate WebIDL type casting for NaN value in lastModified option.
-    const lastModified = options.lastModified === undefined ? Date.now() : Number(options.lastModified)
-    if (!Number.isNaN(lastModified)) {
-      this.#lastModified = lastModified
-    }
-
-    this.#name = String(fileName)
-  }
-
-  get name () {
-    return this.#name
-  }
-
-  get lastModified () {
-    return this.#lastModified
-  }
-
-  get [Symbol.toStringTag] () {
-    return 'File'
-  }
-
-  static [Symbol.hasInstance] (object) {
-    return !!object && object instanceof Blob &&
-      /^(File)$/.test(object[Symbol.toStringTag])
-  }
-}
-
-/** @type {typeof globalThis.File} */// @ts-ignore
-export const File = _File
-export default File

package/test/node_modules/fetch-blob/from.d.ts

@@ -1,26 +0,0 @@
-export default blobFromSync;
-/**
- * @param {string} path filepath on the disk
- * @param {string} [type] mimetype to use
- */
-export function blobFromSync(path: string, type?: string): Blob;
-import File from "./file.js";
-import Blob from "./index.js";
-/**
- * @param {string} path filepath on the disk
- * @param {string} [type] mimetype to use
- * @returns {Promise<Blob>}
- */
-export function blobFrom(path: string, type?: string): Promise<Blob>;
-/**
- * @param {string} path filepath on the disk
- * @param {string} [type] mimetype to use
- * @returns {Promise<File>}
- */
-export function fileFrom(path: string, type?: string): Promise<File>;
-/**
- * @param {string} path filepath on the disk
- * @param {string} [type] mimetype to use
- */
-export function fileFromSync(path: string, type?: string): File;
-export { File, Blob };

package/test/node_modules/fetch-blob/from.js

@@ -1,100 +0,0 @@
-import { statSync, createReadStream, promises as fs } from 'node:fs'
-import { basename } from 'node:path'
-import DOMException from 'node-domexception'
-
-import File from './file.js'
-import Blob from './index.js'
-
-const { stat } = fs
-
-/**
- * @param {string} path filepath on the disk
- * @param {string} [type] mimetype to use
- */
-const blobFromSync = (path, type) => fromBlob(statSync(path), path, type)
-
-/**
- * @param {string} path filepath on the disk
- * @param {string} [type] mimetype to use
- * @returns {Promise<Blob>}
- */
-const blobFrom = (path, type) => stat(path).then(stat => fromBlob(stat, path, type))
-
-/**
- * @param {string} path filepath on the disk
- * @param {string} [type] mimetype to use
- * @returns {Promise<File>}
- */
-const fileFrom = (path, type) => stat(path).then(stat => fromFile(stat, path, type))
-
-/**
- * @param {string} path filepath on the disk
- * @param {string} [type] mimetype to use
- */
-const fileFromSync = (path, type) => fromFile(statSync(path), path, type)
-
-// @ts-ignore
-const fromBlob = (stat, path, type = '') => new Blob([new BlobDataItem({
-  path,
-  size: stat.size,
-  lastModified: stat.mtimeMs,
-  start: 0
-})], { type })
-
-// @ts-ignore
-const fromFile = (stat, path, type = '') => new File([new BlobDataItem({
-  path,
-  size: stat.size,
-  lastModified: stat.mtimeMs,
-  start: 0
-})], basename(path), { type, lastModified: stat.mtimeMs })
-
-/**
- * This is a blob backed up by a file on the disk
- * with minium requirement. Its wrapped around a Blob as a blobPart
- * so you have no direct access to this.
- *
- * @private
- */
-class BlobDataItem {
-  #path
-  #start
-
-  constructor (options) {
-    this.#path = options.path
-    this.#start = options.start
-    this.size = options.size
-    this.lastModified = options.lastModified
-  }
-
-  /**
-   * Slicing arguments is first validated and formatted
-   * to not be out of range by Blob.prototype.slice
-   */
-  slice (start, end) {
-    return new BlobDataItem({
-      path: this.#path,
-      lastModified: this.lastModified,
-      size: end - start,
-      start: this.#start + start
-    })
-  }
-
-  async * stream () {
-    const { mtimeMs } = await stat(this.#path)
-    if (mtimeMs > this.lastModified) {
-      throw new DOMException('The requested file could not be read, typically due to permission problems that have occurred after a reference to a file was acquired.', 'NotReadableError')
-    }
-    yield * createReadStream(this.#path, {
-      start: this.#start,
-      end: this.#start + this.size - 1
-    })
-  }
-
-  get [Symbol.toStringTag] () {
-    return 'Blob'
-  }
-}
-
-export default blobFromSync
-export { File, Blob, blobFrom, blobFromSync, fileFrom, fileFromSync }