brut-js 0.15.0 → 0.16.0-pre

package/docs/node_modules/mdurl/lib/encode.mjs

@@ -1,89 +0,0 @@
-const encodeCache = {}
-
-// Create a lookup array where anything but characters in `chars` string
-// and alphanumeric chars is percent-encoded.
-//
-function getEncodeCache (exclude) {
-  let cache = encodeCache[exclude]
-  if (cache) { return cache }
-
-  cache = encodeCache[exclude] = []
-
-  for (let i = 0; i < 128; i++) {
-    const ch = String.fromCharCode(i)
-
-    if (/^[0-9a-z]$/i.test(ch)) {
-      // always allow unencoded alphanumeric characters
-      cache.push(ch)
-    } else {
-      cache.push('%' + ('0' + i.toString(16).toUpperCase()).slice(-2))
-    }
-  }
-
-  for (let i = 0; i < exclude.length; i++) {
-    cache[exclude.charCodeAt(i)] = exclude[i]
-  }
-
-  return cache
-}
-
-// Encode unsafe characters with percent-encoding, skipping already
-// encoded sequences.
-//
-//  - string       - string to encode
-//  - exclude      - list of characters to ignore (in addition to a-zA-Z0-9)
-//  - keepEscaped  - don't encode '%' in a correct escape sequence (default: true)
-//
-function encode (string, exclude, keepEscaped) {
-  if (typeof exclude !== 'string') {
-    // encode(string, keepEscaped)
-    keepEscaped = exclude
-    exclude = encode.defaultChars
-  }
-
-  if (typeof keepEscaped === 'undefined') {
-    keepEscaped = true
-  }
-
-  const cache = getEncodeCache(exclude)
-  let result = ''
-
-  for (let i = 0, l = string.length; i < l; i++) {
-    const code = string.charCodeAt(i)
-
-    if (keepEscaped && code === 0x25 /* % */ && i + 2 < l) {
-      if (/^[0-9a-f]{2}$/i.test(string.slice(i + 1, i + 3))) {
-        result += string.slice(i, i + 3)
-        i += 2
-        continue
-      }
-    }
-
-    if (code < 128) {
-      result += cache[code]
-      continue
-    }
-
-    if (code >= 0xD800 && code <= 0xDFFF) {
-      if (code >= 0xD800 && code <= 0xDBFF && i + 1 < l) {
-        const nextCode = string.charCodeAt(i + 1)
-        if (nextCode >= 0xDC00 && nextCode <= 0xDFFF) {
-          result += encodeURIComponent(string[i] + string[i + 1])
-          i++
-          continue
-        }
-      }
-      result += '%EF%BF%BD'
-      continue
-    }
-
-    result += encodeURIComponent(string[i])
-  }
-
-  return result
-}
-
-encode.defaultChars = ";/?:@&=+$,-_.!~*'()#"
-encode.componentChars = "-_.!~*'()"
-
-export default encode

package/docs/node_modules/mdurl/lib/format.mjs

@@ -1,21 +0,0 @@
-export default function format (url) {
-  let result = ''
-
-  result += url.protocol || ''
-  result += url.slashes ? '//' : ''
-  result += url.auth ? url.auth + '@' : ''
-
-  if (url.hostname && url.hostname.indexOf(':') !== -1) {
-    // ipv6 address
-    result += '[' + url.hostname + ']'
-  } else {
-    result += url.hostname || ''
-  }
-
-  result += url.port ? ':' + url.port : ''
-  result += url.pathname || ''
-  result += url.search || ''
-  result += url.hash || ''
-
-  return result
-};

package/docs/node_modules/mdurl/lib/parse.mjs

@@ -1,308 +0,0 @@
-// Copyright Joyent, Inc. and other Node 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.
-
-//
-// Changes from joyent/node:
-//
-// 1. No leading slash in paths,
-//    e.g. in `url.parse('http://foo?bar')` pathname is ``, not `/`
-//
-// 2. Backslashes are not replaced with slashes,
-//    so `http:\\example.org\` is treated like a relative path
-//
-// 3. Trailing colon is treated like a part of the path,
-//    i.e. in `http://example.org:foo` pathname is `:foo`
-//
-// 4. Nothing is URL-encoded in the resulting object,
-//    (in joyent/node some chars in auth and paths are encoded)
-//
-// 5. `url.parse()` does not have `parseQueryString` argument
-//
-// 6. Removed extraneous result properties: `host`, `path`, `query`, etc.,
-//    which can be constructed using other parts of the url.
-//
-
-function Url () {
-  this.protocol = null
-  this.slashes = null
-  this.auth = null
-  this.port = null
-  this.hostname = null
-  this.hash = null
-  this.search = null
-  this.pathname = null
-}
-
-// Reference: RFC 3986, RFC 1808, RFC 2396
-
-// define these here so at least they only have to be
-// compiled once on the first module load.
-const protocolPattern = /^([a-z0-9.+-]+:)/i
-const portPattern = /:[0-9]*$/
-
-// Special case for a simple path URL
-/* eslint-disable-next-line no-useless-escape */
-const simplePathPattern = /^(\/\/?(?!\/)[^\?\s]*)(\?[^\s]*)?$/
-
-// RFC 2396: characters reserved for delimiting URLs.
-// We actually just auto-escape these.
-const delims = ['<', '>', '"', '`', ' ', '\r', '\n', '\t']
-
-// RFC 2396: characters not allowed for various reasons.
-const unwise = ['{', '}', '|', '\\', '^', '`'].concat(delims)
-
-// Allowed by RFCs, but cause of XSS attacks.  Always escape these.
-const autoEscape = ['\''].concat(unwise)
-// Characters that are never ever allowed in a hostname.
-// Note that any invalid chars are also handled, but these
-// are the ones that are *expected* to be seen, so we fast-path
-// them.
-const nonHostChars = ['%', '/', '?', ';', '#'].concat(autoEscape)
-const hostEndingChars = ['/', '?', '#']
-const hostnameMaxLen = 255
-const hostnamePartPattern = /^[+a-z0-9A-Z_-]{0,63}$/
-const hostnamePartStart = /^([+a-z0-9A-Z_-]{0,63})(.*)$/
-// protocols that can allow "unsafe" and "unwise" chars.
-// protocols that never have a hostname.
-const hostlessProtocol = {
-  javascript: true,
-  'javascript:': true
-}
-// protocols that always contain a // bit.
-const slashedProtocol = {
-  http: true,
-  https: true,
-  ftp: true,
-  gopher: true,
-  file: true,
-  'http:': true,
-  'https:': true,
-  'ftp:': true,
-  'gopher:': true,
-  'file:': true
-}
-
-function urlParse (url, slashesDenoteHost) {
-  if (url && url instanceof Url) return url
-
-  const u = new Url()
-  u.parse(url, slashesDenoteHost)
-  return u
-}
-
-Url.prototype.parse = function (url, slashesDenoteHost) {
-  let lowerProto, hec, slashes
-  let rest = url
-
-  // trim before proceeding.
-  // This is to support parse stuff like "  http://foo.com  \n"
-  rest = rest.trim()
-
-  if (!slashesDenoteHost && url.split('#').length === 1) {
-    // Try fast path regexp
-    const simplePath = simplePathPattern.exec(rest)
-    if (simplePath) {
-      this.pathname = simplePath[1]
-      if (simplePath[2]) {
-        this.search = simplePath[2]
-      }
-      return this
-    }
-  }
-
-  let proto = protocolPattern.exec(rest)
-  if (proto) {
-    proto = proto[0]
-    lowerProto = proto.toLowerCase()
-    this.protocol = proto
-    rest = rest.substr(proto.length)
-  }
-
-  // figure out if it's got a host
-  // user@server is *always* interpreted as a hostname, and url
-  // resolution will treat //foo/bar as host=foo,path=bar because that's
-  // how the browser resolves relative URLs.
-  /* eslint-disable-next-line no-useless-escape */
-  if (slashesDenoteHost || proto || rest.match(/^\/\/[^@\/]+@[^@\/]+/)) {
-    slashes = rest.substr(0, 2) === '//'
-    if (slashes && !(proto && hostlessProtocol[proto])) {
-      rest = rest.substr(2)
-      this.slashes = true
-    }
-  }
-
-  if (!hostlessProtocol[proto] &&
-      (slashes || (proto && !slashedProtocol[proto]))) {
-    // there's a hostname.
-    // the first instance of /, ?, ;, or # ends the host.
-    //
-    // If there is an @ in the hostname, then non-host chars *are* allowed
-    // to the left of the last @ sign, unless some host-ending character
-    // comes *before* the @-sign.
-    // URLs are obnoxious.
-    //
-    // ex:
-    // http://a@b@c/ => user:a@b host:c
-    // http://a@b?@c => user:a host:c path:/?@c
-
-    // v0.12 TODO(isaacs): This is not quite how Chrome does things.
-    // Review our test case against browsers more comprehensively.
-
-    // find the first instance of any hostEndingChars
-    let hostEnd = -1
-    for (let i = 0; i < hostEndingChars.length; i++) {
-      hec = rest.indexOf(hostEndingChars[i])
-      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {
-        hostEnd = hec
-      }
-    }
-
-    // at this point, either we have an explicit point where the
-    // auth portion cannot go past, or the last @ char is the decider.
-    let auth, atSign
-    if (hostEnd === -1) {
-      // atSign can be anywhere.
-      atSign = rest.lastIndexOf('@')
-    } else {
-      // atSign must be in auth portion.
-      // http://a@b/c@d => host:b auth:a path:/c@d
-      atSign = rest.lastIndexOf('@', hostEnd)
-    }
-
-    // Now we have a portion which is definitely the auth.
-    // Pull that off.
-    if (atSign !== -1) {
-      auth = rest.slice(0, atSign)
-      rest = rest.slice(atSign + 1)
-      this.auth = auth
-    }
-
-    // the host is the remaining to the left of the first non-host char
-    hostEnd = -1
-    for (let i = 0; i < nonHostChars.length; i++) {
-      hec = rest.indexOf(nonHostChars[i])
-      if (hec !== -1 && (hostEnd === -1 || hec < hostEnd)) {
-        hostEnd = hec
-      }
-    }
-    // if we still have not hit it, then the entire thing is a host.
-    if (hostEnd === -1) {
-      hostEnd = rest.length
-    }
-
-    if (rest[hostEnd - 1] === ':') { hostEnd-- }
-    const host = rest.slice(0, hostEnd)
-    rest = rest.slice(hostEnd)
-
-    // pull out port.
-    this.parseHost(host)
-
-    // we've indicated that there is a hostname,
-    // so even if it's empty, it has to be present.
-    this.hostname = this.hostname || ''
-
-    // if hostname begins with [ and ends with ]
-    // assume that it's an IPv6 address.
-    const ipv6Hostname = this.hostname[0] === '[' &&
-        this.hostname[this.hostname.length - 1] === ']'
-
-    // validate a little.
-    if (!ipv6Hostname) {
-      const hostparts = this.hostname.split(/\./)
-      for (let i = 0, l = hostparts.length; i < l; i++) {
-        const part = hostparts[i]
-        if (!part) { continue }
-        if (!part.match(hostnamePartPattern)) {
-          let newpart = ''
-          for (let j = 0, k = part.length; j < k; j++) {
-            if (part.charCodeAt(j) > 127) {
-              // we replace non-ASCII char with a temporary placeholder
-              // we need this to make sure size of hostname is not
-              // broken by replacing non-ASCII by nothing
-              newpart += 'x'
-            } else {
-              newpart += part[j]
-            }
-          }
-          // we test again with ASCII char only
-          if (!newpart.match(hostnamePartPattern)) {
-            const validParts = hostparts.slice(0, i)
-            const notHost = hostparts.slice(i + 1)
-            const bit = part.match(hostnamePartStart)
-            if (bit) {
-              validParts.push(bit[1])
-              notHost.unshift(bit[2])
-            }
-            if (notHost.length) {
-              rest = notHost.join('.') + rest
-            }
-            this.hostname = validParts.join('.')
-            break
-          }
-        }
-      }
-    }
-
-    if (this.hostname.length > hostnameMaxLen) {
-      this.hostname = ''
-    }
-
-    // strip [ and ] from the hostname
-    // the host field still retains them, though
-    if (ipv6Hostname) {
-      this.hostname = this.hostname.substr(1, this.hostname.length - 2)
-    }
-  }
-
-  // chop off from the tail first.
-  const hash = rest.indexOf('#')
-  if (hash !== -1) {
-    // got a fragment string.
-    this.hash = rest.substr(hash)
-    rest = rest.slice(0, hash)
-  }
-  const qm = rest.indexOf('?')
-  if (qm !== -1) {
-    this.search = rest.substr(qm)
-    rest = rest.slice(0, qm)
-  }
-  if (rest) { this.pathname = rest }
-  if (slashedProtocol[lowerProto] &&
-      this.hostname && !this.pathname) {
-    this.pathname = ''
-  }
-
-  return this
-}
-
-Url.prototype.parseHost = function (host) {
-  let port = portPattern.exec(host)
-  if (port) {
-    port = port[0]
-    if (port !== ':') {
-      this.port = port.substr(1)
-    }
-    host = host.substr(0, host.length - port.length)
-  }
-  if (host) { this.hostname = host }
-}
-
-export default urlParse

package/docs/node_modules/mdurl/package.json

@@ -1,37 +0,0 @@
-{
-  "name": "mdurl",
-  "version": "2.0.0",
-  "description": "URL utilities for markdown-it",
-  "repository": "markdown-it/mdurl",
-  "license": "MIT",
-  "main": "build/index.cjs.js",
-  "module": "index.mjs",
-  "exports": {
-    ".": {
-      "require": "./build/index.cjs.js",
-      "import": "./index.mjs"
-    },
-    "./*": {
-      "require": "./*",
-      "import": "./*"
-    }
-  },
-  "scripts": {
-    "lint": "eslint .",
-    "build": "rollup -c",
-    "test": "npm run lint && npm run build && c8 --exclude build --exclude test -r text -r html -r lcov mocha",
-    "prepublishOnly": "npm run lint && npm run build"
-  },
-  "files": [
-    "index.mjs",
-    "lib/",
-    "build/"
-  ],
-  "devDependencies": {
-    "c8": "^8.0.1",
-    "eslint": "^8.54.0",
-    "eslint-config-standard": "^17.1.0",
-    "mocha": "^10.2.0",
-    "rollup": "^4.6.1"
-  }
-}

package/docs/node_modules/mkdirp/CHANGELOG.md

@@ -1,15 +0,0 @@
-# Changers Lorgs!
-
-## 1.0
-
-Full rewrite.  Essentially a brand new module.
-
-- Return a promise instead of taking a callback.
-- Use native `fs.mkdir(path, { recursive: true })` when available.
-- Drop support for outdated Node.js versions.  (Technically still works on
-  Node.js v8, but only 10 and above are officially supported.)
-
-## 0.x
-
-Original and most widely used recursive directory creation implementation
-in JavaScript, dating back to 2010.

package/docs/node_modules/mkdirp/LICENSE

@@ -1,21 +0,0 @@
-Copyright James Halliday (mail@substack.net) and Isaac Z. Schlueter (i@izs.me)
-
-This project is free software released under the MIT license:
-
-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/docs/node_modules/mkdirp/bin/cmd.js

@@ -1,68 +0,0 @@
-#!/usr/bin/env node
-
-const usage = () => `
-usage: mkdirp [DIR1,DIR2..] {OPTIONS}
-
-  Create each supplied directory including any necessary parent directories
-  that don't yet exist.
-
-  If the directory already exists, do nothing.
-
-OPTIONS are:
-
-  -m<mode>       If a directory needs to be created, set the mode as an octal
-  --mode=<mode>  permission string.
-
-  -v --version   Print the mkdirp version number
-
-  -h --help      Print this helpful banner
-
-  -p --print     Print the first directories created for each path provided
-
-  --manual       Use manual implementation, even if native is available
-`
-
-const dirs = []
-const opts = {}
-let print = false
-let dashdash = false
-let manual = false
-for (const arg of process.argv.slice(2)) {
-  if (dashdash)
-    dirs.push(arg)
-  else if (arg === '--')
-    dashdash = true
-  else if (arg === '--manual')
-    manual = true
-  else if (/^-h/.test(arg) || /^--help/.test(arg)) {
-    console.log(usage())
-    process.exit(0)
-  } else if (arg === '-v' || arg === '--version') {
-    console.log(require('../package.json').version)
-    process.exit(0)
-  } else if (arg === '-p' || arg === '--print') {
-    print = true
-  } else if (/^-m/.test(arg) || /^--mode=/.test(arg)) {
-    const mode = parseInt(arg.replace(/^(-m|--mode=)/, ''), 8)
-    if (isNaN(mode)) {
-      console.error(`invalid mode argument: ${arg}\nMust be an octal number.`)
-      process.exit(1)
-    }
-    opts.mode = mode
-  } else
-    dirs.push(arg)
-}
-
-const mkdirp = require('../')
-const impl = manual ? mkdirp.manual : mkdirp
-if (dirs.length === 0)
-  console.error(usage())
-
-Promise.all(dirs.map(dir => impl(dir, opts)))
-  .then(made => print ? made.forEach(m => m && console.log(m)) : null)
-  .catch(er => {
-    console.error(er.message)
-    if (er.code)
-      console.error('  code: ' + er.code)
-    process.exit(1)
-  })

package/docs/node_modules/mkdirp/index.js

@@ -1,31 +0,0 @@
-const optsArg = require('./lib/opts-arg.js')
-const pathArg = require('./lib/path-arg.js')
-
-const {mkdirpNative, mkdirpNativeSync} = require('./lib/mkdirp-native.js')
-const {mkdirpManual, mkdirpManualSync} = require('./lib/mkdirp-manual.js')
-const {useNative, useNativeSync} = require('./lib/use-native.js')
-
-
-const mkdirp = (path, opts) => {
-  path = pathArg(path)
-  opts = optsArg(opts)
-  return useNative(opts)
-    ? mkdirpNative(path, opts)
-    : mkdirpManual(path, opts)
-}
-
-const mkdirpSync = (path, opts) => {
-  path = pathArg(path)
-  opts = optsArg(opts)
-  return useNativeSync(opts)
-    ? mkdirpNativeSync(path, opts)
-    : mkdirpManualSync(path, opts)
-}
-
-mkdirp.sync = mkdirpSync
-mkdirp.native = (path, opts) => mkdirpNative(pathArg(path), optsArg(opts))
-mkdirp.manual = (path, opts) => mkdirpManual(pathArg(path), optsArg(opts))
-mkdirp.nativeSync = (path, opts) => mkdirpNativeSync(pathArg(path), optsArg(opts))
-mkdirp.manualSync = (path, opts) => mkdirpManualSync(pathArg(path), optsArg(opts))
-
-module.exports = mkdirp

package/docs/node_modules/mkdirp/lib/find-made.js

@@ -1,29 +0,0 @@
-const {dirname} = require('path')
-
-const findMade = (opts, parent, path = undefined) => {
-  // we never want the 'made' return value to be a root directory
-  if (path === parent)
-    return Promise.resolve()
-
-  return opts.statAsync(parent).then(
-    st => st.isDirectory() ? path : undefined, // will fail later
-    er => er.code === 'ENOENT'
-      ? findMade(opts, dirname(parent), parent)
-      : undefined
-  )
-}
-
-const findMadeSync = (opts, parent, path = undefined) => {
-  if (path === parent)
-    return undefined
-
-  try {
-    return opts.statSync(parent).isDirectory() ? path : undefined
-  } catch (er) {
-    return er.code === 'ENOENT'
-      ? findMadeSync(opts, dirname(parent), parent)
-      : undefined
-  }
-}
-
-module.exports = {findMade, findMadeSync}

package/docs/node_modules/mkdirp/lib/mkdirp-manual.js

@@ -1,64 +0,0 @@
-const {dirname} = require('path')
-
-const mkdirpManual = (path, opts, made) => {
-  opts.recursive = false
-  const parent = dirname(path)
-  if (parent === path) {
-    return opts.mkdirAsync(path, opts).catch(er => {
-      // swallowed by recursive implementation on posix systems
-      // any other error is a failure
-      if (er.code !== 'EISDIR')
-        throw er
-    })
-  }
-
-  return opts.mkdirAsync(path, opts).then(() => made || path, er => {
-    if (er.code === 'ENOENT')
-      return mkdirpManual(parent, opts)
-        .then(made => mkdirpManual(path, opts, made))
-    if (er.code !== 'EEXIST' && er.code !== 'EROFS')
-      throw er
-    return opts.statAsync(path).then(st => {
-      if (st.isDirectory())
-        return made
-      else
-        throw er
-    }, () => { throw er })
-  })
-}
-
-const mkdirpManualSync = (path, opts, made) => {
-  const parent = dirname(path)
-  opts.recursive = false
-
-  if (parent === path) {
-    try {
-      return opts.mkdirSync(path, opts)
-    } catch (er) {
-      // swallowed by recursive implementation on posix systems
-      // any other error is a failure
-      if (er.code !== 'EISDIR')
-        throw er
-      else
-        return
-    }
-  }
-
-  try {
-    opts.mkdirSync(path, opts)
-    return made || path
-  } catch (er) {
-    if (er.code === 'ENOENT')
-      return mkdirpManualSync(path, opts, mkdirpManualSync(parent, opts, made))
-    if (er.code !== 'EEXIST' && er.code !== 'EROFS')
-      throw er
-    try {
-      if (!opts.statSync(path).isDirectory())
-        throw er
-    } catch (_) {
-      throw er
-    }
-  }
-}
-
-module.exports = {mkdirpManual, mkdirpManualSync}