llonebot-dist 7.0.1 → 7.1.0

package/node_modules/object-inspect/test/values.js

@@ -0,0 +1,261 @@
+'use strict';
+
+var inspect = require('../');
+var test = require('tape');
+var mockProperty = require('mock-property');
+var hasSymbols = require('has-symbols/shams')();
+var hasToStringTag = require('has-tostringtag/shams')();
+var forEach = require('for-each');
+var semver = require('semver');
+
+test('values', function (t) {
+    t.plan(1);
+    var obj = [{}, [], { 'a-b': 5 }];
+    t.equal(inspect(obj), '[ {}, [], { \'a-b\': 5 } ]');
+});
+
+test('arrays with properties', function (t) {
+    t.plan(1);
+    var arr = [3];
+    arr.foo = 'bar';
+    var obj = [1, 2, arr];
+    obj.baz = 'quux';
+    obj.index = -1;
+    t.equal(inspect(obj), '[ 1, 2, [ 3, foo: \'bar\' ], baz: \'quux\', index: -1 ]');
+});
+
+test('has', function (t) {
+    t.plan(1);
+    t.teardown(mockProperty(Object.prototype, 'hasOwnProperty', { 'delete': true }));
+
+    t.equal(inspect({ a: 1, b: 2 }), '{ a: 1, b: 2 }');
+});
+
+test('indexOf seen', function (t) {
+    t.plan(1);
+    var xs = [1, 2, 3, {}];
+    xs.push(xs);
+
+    var seen = [];
+    seen.indexOf = undefined;
+
+    t.equal(
+        inspect(xs, {}, 0, seen),
+        '[ 1, 2, 3, {}, [Circular] ]'
+    );
+});
+
+test('seen seen', function (t) {
+    t.plan(1);
+    var xs = [1, 2, 3];
+
+    var seen = [xs];
+    seen.indexOf = undefined;
+
+    t.equal(
+        inspect(xs, {}, 0, seen),
+        '[Circular]'
+    );
+});
+
+test('seen seen seen', function (t) {
+    t.plan(1);
+    var xs = [1, 2, 3];
+
+    var seen = [5, xs];
+    seen.indexOf = undefined;
+
+    t.equal(
+        inspect(xs, {}, 0, seen),
+        '[Circular]'
+    );
+});
+
+test('symbols', { skip: !hasSymbols }, function (t) {
+    var sym = Symbol('foo');
+    t.equal(inspect(sym), 'Symbol(foo)', 'Symbol("foo") should be "Symbol(foo)"');
+    if (typeof sym === 'symbol') {
+        // Symbol shams are incapable of differentiating boxed from unboxed symbols
+        t.equal(inspect(Object(sym)), 'Object(Symbol(foo))', 'Object(Symbol("foo")) should be "Object(Symbol(foo))"');
+    }
+
+    t.test('toStringTag', { skip: !hasToStringTag }, function (st) {
+        st.plan(1);
+
+        var faker = {};
+        faker[Symbol.toStringTag] = 'Symbol';
+        st.equal(
+            inspect(faker),
+            '{ [Symbol(Symbol.toStringTag)]: \'Symbol\' }',
+            'object lying about being a Symbol inspects as an object'
+        );
+    });
+
+    t.end();
+});
+
+test('Map', { skip: typeof Map !== 'function' }, function (t) {
+    var map = new Map();
+    map.set({ a: 1 }, ['b']);
+    map.set(3, NaN);
+    var expectedString = 'Map (2) {' + inspect({ a: 1 }) + ' => ' + inspect(['b']) + ', 3 => NaN}';
+    t.equal(inspect(map), expectedString, 'new Map([[{ a: 1 }, ["b"]], [3, NaN]]) should show size and contents');
+    t.equal(inspect(new Map()), 'Map (0) {}', 'empty Map should show as empty');
+
+    var nestedMap = new Map();
+    nestedMap.set(nestedMap, map);
+    t.equal(inspect(nestedMap), 'Map (1) {[Circular] => ' + expectedString + '}', 'Map containing a Map should work');
+
+    t.end();
+});
+
+test('WeakMap', { skip: typeof WeakMap !== 'function' }, function (t) {
+    var map = new WeakMap();
+    map.set({ a: 1 }, ['b']);
+    var expectedString = 'WeakMap { ? }';
+    t.equal(inspect(map), expectedString, 'new WeakMap([[{ a: 1 }, ["b"]]]) should not show size or contents');
+    t.equal(inspect(new WeakMap()), 'WeakMap { ? }', 'empty WeakMap should not show as empty');
+
+    t.end();
+});
+
+test('Set', { skip: typeof Set !== 'function' }, function (t) {
+    var set = new Set();
+    set.add({ a: 1 });
+    set.add(['b']);
+    var expectedString = 'Set (2) {' + inspect({ a: 1 }) + ', ' + inspect(['b']) + '}';
+    t.equal(inspect(set), expectedString, 'new Set([{ a: 1 }, ["b"]]) should show size and contents');
+    t.equal(inspect(new Set()), 'Set (0) {}', 'empty Set should show as empty');
+
+    var nestedSet = new Set();
+    nestedSet.add(set);
+    nestedSet.add(nestedSet);
+    t.equal(inspect(nestedSet), 'Set (2) {' + expectedString + ', [Circular]}', 'Set containing a Set should work');
+
+    t.end();
+});
+
+test('WeakSet', { skip: typeof WeakSet !== 'function' }, function (t) {
+    var map = new WeakSet();
+    map.add({ a: 1 });
+    var expectedString = 'WeakSet { ? }';
+    t.equal(inspect(map), expectedString, 'new WeakSet([{ a: 1 }]) should not show size or contents');
+    t.equal(inspect(new WeakSet()), 'WeakSet { ? }', 'empty WeakSet should not show as empty');
+
+    t.end();
+});
+
+test('WeakRef', { skip: typeof WeakRef !== 'function' }, function (t) {
+    var ref = new WeakRef({ a: 1 });
+    var expectedString = 'WeakRef { ? }';
+    t.equal(inspect(ref), expectedString, 'new WeakRef({ a: 1 }) should not show contents');
+
+    t.end();
+});
+
+test('FinalizationRegistry', { skip: typeof FinalizationRegistry !== 'function' }, function (t) {
+    var registry = new FinalizationRegistry(function () {});
+    var expectedString = 'FinalizationRegistry [FinalizationRegistry] {}';
+    t.equal(inspect(registry), expectedString, 'new FinalizationRegistry(function () {}) should work normallys');
+
+    t.end();
+});
+
+test('Strings', function (t) {
+    var str = 'abc';
+
+    t.equal(inspect(str), "'" + str + "'", 'primitive string shows as such');
+    t.equal(inspect(str, { quoteStyle: 'single' }), "'" + str + "'", 'primitive string shows as such, single quoted');
+    t.equal(inspect(str, { quoteStyle: 'double' }), '"' + str + '"', 'primitive string shows as such, double quoted');
+    t.equal(inspect(Object(str)), 'Object(' + inspect(str) + ')', 'String object shows as such');
+    t.equal(inspect(Object(str), { quoteStyle: 'single' }), 'Object(' + inspect(str, { quoteStyle: 'single' }) + ')', 'String object shows as such, single quoted');
+    t.equal(inspect(Object(str), { quoteStyle: 'double' }), 'Object(' + inspect(str, { quoteStyle: 'double' }) + ')', 'String object shows as such, double quoted');
+
+    t.end();
+});
+
+test('Numbers', function (t) {
+    var num = 42;
+
+    t.equal(inspect(num), String(num), 'primitive number shows as such');
+    t.equal(inspect(Object(num)), 'Object(' + inspect(num) + ')', 'Number object shows as such');
+
+    t.end();
+});
+
+test('Booleans', function (t) {
+    t.equal(inspect(true), String(true), 'primitive true shows as such');
+    t.equal(inspect(Object(true)), 'Object(' + inspect(true) + ')', 'Boolean object true shows as such');
+
+    t.equal(inspect(false), String(false), 'primitive false shows as such');
+    t.equal(inspect(Object(false)), 'Object(' + inspect(false) + ')', 'Boolean false object shows as such');
+
+    t.end();
+});
+
+test('Date', function (t) {
+    var now = new Date();
+    t.equal(inspect(now), String(now), 'Date shows properly');
+    t.equal(inspect(new Date(NaN)), 'Invalid Date', 'Invalid Date shows properly');
+
+    t.end();
+});
+
+test('RegExps', function (t) {
+    t.equal(inspect(/a/g), '/a/g', 'regex shows properly');
+    t.equal(inspect(new RegExp('abc', 'i')), '/abc/i', 'new RegExp shows properly');
+
+    var match = 'abc abc'.match(/[ab]+/);
+    delete match.groups; // for node < 10
+    t.equal(inspect(match), '[ \'ab\', index: 0, input: \'abc abc\' ]', 'RegExp match object shows properly');
+
+    t.end();
+});
+
+test('Proxies', { skip: typeof Proxy !== 'function' || !hasToStringTag }, function (t) {
+    var target = { proxy: true };
+    var fake = new Proxy(target, { has: function () { return false; } });
+
+    // needed to work around a weird difference in node v6.0 - v6.4 where non-present properties are not logged
+    var isNode60 = semver.satisfies(process.version, '6.0 - 6.4');
+
+    forEach([
+        'Boolean',
+        'Number',
+        'String',
+        'Symbol',
+        'Date'
+    ], function (tag) {
+        target[Symbol.toStringTag] = tag;
+
+        t.equal(
+            inspect(fake),
+            '{ ' + (isNode60 ? '' : 'proxy: true, ') + '[Symbol(Symbol.toStringTag)]: \'' + tag + '\' }',
+            'Proxy for + ' + tag + ' shows as the target, which has no slots'
+        );
+    });
+
+    t.end();
+});
+
+test('fakers', { skip: !hasToStringTag }, function (t) {
+    var target = { proxy: false };
+
+    forEach([
+        'Boolean',
+        'Number',
+        'String',
+        'Symbol',
+        'Date'
+    ], function (tag) {
+        target[Symbol.toStringTag] = tag;
+
+        t.equal(
+            inspect(target),
+            '{ proxy: false, [Symbol(Symbol.toStringTag)]: \'' + tag + '\' }',
+            'Object pretending to be ' + tag + ' does not trick us'
+        );
+    });
+
+    t.end();
+});

package/node_modules/object-inspect/test-core-js.js

@@ -0,0 +1,26 @@
+'use strict';
+
+require('core-js');
+
+var inspect = require('./');
+var test = require('tape');
+
+test('Maps', function (t) {
+    t.equal(inspect(new Map([[1, 2]])), 'Map (1) {1 => 2}');
+    t.end();
+});
+
+test('WeakMaps', function (t) {
+    t.equal(inspect(new WeakMap([[{}, 2]])), 'WeakMap { ? }');
+    t.end();
+});
+
+test('Sets', function (t) {
+    t.equal(inspect(new Set([[1, 2]])), 'Set (1) {[ 1, 2 ]}');
+    t.end();
+});
+
+test('WeakSets', function (t) {
+    t.equal(inspect(new WeakSet([[1, 2]])), 'WeakSet { ? }');
+    t.end();
+});

package/node_modules/object-inspect/util.inspect.js

@@ -0,0 +1 @@
+module.exports = require('util').inspect;

package/node_modules/reggol/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2021-present Shigma
+
+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/node_modules/reggol/README.md

@@ -0,0 +1,8 @@
+# reggol
+
+[![Codecov](https://img.shields.io/codecov/c/github/shigma/reggol?style=flat-square)](https://codecov.io/gh/shigma/reggol)
+[![downloads](https://img.shields.io/npm/dm/reggol?style=flat-square)](https://www.npmjs.com/package/reggol)
+[![npm](https://img.shields.io/npm/v/reggol?style=flat-square)](https://www.npmjs.com/package/reggol)
+[![GitHub](https://img.shields.io/github/license/shigma/reggol?style=flat-square)](https://github.com/shigma/reggol/blob/master/LICENSE)
+
+Logger for professionals.

package/node_modules/reggol/index.d.ts

@@ -0,0 +1,79 @@
+declare namespace Logger {
+  export interface LevelConfig {
+    base: number
+    [K: string]: Level
+  }
+
+  export type Level = number | LevelConfig
+  export type Function = (format: any, ...param: any[]) => void
+  export type Type = 'success' | 'error' | 'info' | 'warn' | 'debug'
+  export type Formatter = (this: Logger, value: any) => string
+
+  export interface LabelStyle {
+    width?: number
+    margin?: number
+    align?: 'left' | 'right'
+  }
+
+  export interface Record {
+    id: number
+    meta: Meta
+    name: string
+    type: Type
+    level: number
+    content: string
+    timestamp: number
+  }
+
+  export interface Meta {}
+
+  export interface Target {
+    /**
+     * - 0: no color support
+     * - 1: 16 color support
+     * - 2: 256 color support
+     * - 3: truecolor support
+     */
+    colors?: number
+    showDiff?: boolean
+    showTime?: string
+    label?: LabelStyle
+    record?(record: Record): void
+    print?(text: string): void
+    levels?: LevelConfig
+    timestamp?: number
+  }
+}
+
+declare interface Logger extends Record<Logger.Type, Logger.Function> {}
+
+declare class Logger {
+  // log levels
+  static readonly SILENT = 0
+  static readonly SUCCESS = 1
+  static readonly ERROR = 1
+  static readonly INFO = 2
+  static readonly WARN = 2
+  static readonly DEBUG = 3
+
+  // global config
+  static colors: number[]
+  static instances: Record<string, Logger>
+  static targets: Logger.Target[]
+  static levels: Logger.LevelConfig
+  static formatters: Record<string, Logger.Formatter>
+
+  static color(code: number, value: any, decoration?: string): string
+  static code(name: string, target: Logger.Target): number
+
+  public name: string
+  public level: number
+
+  private code: number
+
+  constructor(name: string, meta?: any)
+
+  extend(namespace: string): Logger
+}
+
+export = Logger

package/node_modules/reggol/lib/browser.mjs

@@ -0,0 +1,299 @@
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
+var __commonJS = (cb, mod) => function __require() {
+  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+
+// src/shared.ts
+import { stdout } from "supports-color";
+import { Time } from "cosmokit";
+var require_shared = __commonJS({
+  "src/shared.ts"(exports, module) {
+    "use strict";
+    var c16 = [6, 2, 3, 4, 5, 1];
+    var c256 = [
+      20,
+      21,
+      26,
+      27,
+      32,
+      33,
+      38,
+      39,
+      40,
+      41,
+      42,
+      43,
+      44,
+      45,
+      56,
+      57,
+      62,
+      63,
+      68,
+      69,
+      74,
+      75,
+      76,
+      77,
+      78,
+      79,
+      80,
+      81,
+      92,
+      93,
+      98,
+      99,
+      112,
+      113,
+      129,
+      134,
+      135,
+      148,
+      149,
+      160,
+      161,
+      162,
+      163,
+      164,
+      165,
+      166,
+      167,
+      168,
+      169,
+      170,
+      171,
+      172,
+      173,
+      178,
+      179,
+      184,
+      185,
+      196,
+      197,
+      198,
+      199,
+      200,
+      201,
+      202,
+      203,
+      204,
+      205,
+      206,
+      207,
+      208,
+      209,
+      214,
+      215,
+      220,
+      221
+    ];
+    function isAggregateError(error) {
+      return error instanceof Error && Array.isArray(error["errors"]);
+    }
+    __name(isAggregateError, "isAggregateError");
+    var Logger = class _Logger {
+      constructor(name, meta) {
+        this.name = name;
+        this.meta = meta;
+        this.createMethod("success", _Logger.SUCCESS);
+        this.createMethod("error", _Logger.ERROR);
+        this.createMethod("info", _Logger.INFO);
+        this.createMethod("warn", _Logger.WARN);
+        this.createMethod("debug", _Logger.DEBUG);
+      }
+      static {
+        __name(this, "Logger");
+      }
+      // log levels
+      static SILENT = 0;
+      static SUCCESS = 1;
+      static ERROR = 1;
+      static INFO = 2;
+      static WARN = 2;
+      static DEBUG = 3;
+      // global config
+      static id = 0;
+      static targets = [{
+        colors: stdout && stdout.level,
+        print(text) {
+          console.log(text);
+        }
+      }];
+      // global registry
+      static formatters = /* @__PURE__ */ Object.create(null);
+      static format(name, formatter) {
+        this.formatters[name] = formatter;
+      }
+      static levels = {
+        base: 2
+      };
+      static color(target, code, value, decoration = "") {
+        if (!target.colors) return "" + value;
+        return `\x1B[3${code < 8 ? code : "8;5;" + code}${target.colors >= 2 ? decoration : ""}m${value}\x1B[0m`;
+      }
+      static code(name, target) {
+        let hash = 0;
+        for (let i = 0; i < name.length; i++) {
+          hash = (hash << 3) - hash + name.charCodeAt(i) + 13;
+          hash |= 0;
+        }
+        const colors = !target.colors ? [] : target.colors >= 2 ? c256 : c16;
+        return colors[Math.abs(hash) % colors.length];
+      }
+      static render(target, record) {
+        const prefix = `[${record.type[0].toUpperCase()}]`;
+        const space = " ".repeat(target.label?.margin ?? 1);
+        let indent = 3 + space.length, output = "";
+        if (target.showTime) {
+          indent += target.showTime.length + space.length;
+          output += _Logger.color(target, 8, Time.template(target.showTime)) + space;
+        }
+        const code = _Logger.code(record.name, target);
+        const label = _Logger.color(target, code, record.name, ";1");
+        const padLength = (target.label?.width ?? 0) + label.length - record.name.length;
+        if (target.label?.align === "right") {
+          output += label.padStart(padLength) + space + prefix + space;
+          indent += (target.label.width ?? 0) + space.length;
+        } else {
+          output += prefix + space + label.padEnd(padLength) + space;
+        }
+        output += record.content.replace(/\n/g, "\n" + " ".repeat(indent));
+        if (target.showDiff && target.timestamp) {
+          const diff = record.timestamp - target.timestamp;
+          output += _Logger.color(target, code, " +" + Time.format(diff));
+        }
+        return output;
+      }
+      extend = /* @__PURE__ */ __name((namespace) => {
+        return new _Logger(`${this.name}:${namespace}`, this.meta);
+      }, "extend");
+      warning = /* @__PURE__ */ __name((format, ...args) => {
+        this.warn(format, ...args);
+      }, "warning");
+      createMethod(type, level) {
+        this[type] = (...args) => {
+          if (args.length === 1 && args[0] instanceof Error) {
+            if (args[0].cause) {
+              this[type](args[0].cause);
+            } else if (isAggregateError(args[0])) {
+              args[0].errors.forEach((error) => this[type](error));
+              return;
+            }
+          }
+          const id = ++_Logger.id;
+          const timestamp = Date.now();
+          for (const target of _Logger.targets) {
+            if (this.getLevel(target) < level) continue;
+            const content = this.format(target, ...args);
+            const record = { id, type, level, name: this.name, meta: this.meta, content, timestamp };
+            if (target.record) {
+              target.record(record);
+            } else {
+              const { print = console.log } = target;
+              print(_Logger.render(target, record));
+            }
+            target.timestamp = timestamp;
+          }
+        };
+      }
+      format(target, ...args) {
+        if (args[0] instanceof Error) {
+          args[0] = args[0].stack || args[0].message;
+          args.unshift("%s");
+        } else if (typeof args[0] !== "string") {
+          args.unshift("%o");
+        }
+        let format = args.shift();
+        format = format.replace(/%([a-zA-Z%])/g, (match, char) => {
+          if (match === "%%") return "%";
+          const formatter = _Logger.formatters[char];
+          if (typeof formatter === "function") {
+            const value = args.shift();
+            return formatter(value, target, this);
+          }
+          return match;
+        });
+        for (let arg of args) {
+          if (typeof arg === "object" && arg) {
+            arg = _Logger.formatters["o"](arg, target, this);
+          }
+          format += " " + arg;
+        }
+        const { maxLength = 10240 } = target;
+        return format.split(/\r?\n/g).map((line) => {
+          return line.slice(0, maxLength) + (line.length > maxLength ? "..." : "");
+        }).join("\n");
+      }
+      getLevel(target) {
+        const paths = this.name.split(":");
+        let config = target?.levels || _Logger.levels;
+        do {
+          config = config[paths.shift()] ?? config["base"];
+        } while (paths.length && typeof config === "object");
+        return config;
+      }
+      get level() {
+        return this.getLevel();
+      }
+      set level(value) {
+        const paths = this.name.split(":");
+        let config = _Logger.levels;
+        while (paths.length > 1) {
+          const name = paths.shift();
+          const value2 = config[name];
+          if (typeof value2 === "object") {
+            config = value2;
+          } else {
+            config = config[name] = { base: value2 ?? config.base };
+          }
+        }
+        config[paths[0]] = value;
+      }
+    };
+    Logger.format("s", (value) => value);
+    Logger.format("d", (value) => +value);
+    Logger.format("j", (value) => JSON.stringify(value));
+    Logger.format("c", (value, target, logger) => {
+      return Logger.color(target, Logger.code(logger.name, target), value);
+    });
+    Logger.format("C", (value, target) => {
+      return Logger.color(target, 15, value, ";1");
+    });
+    module.exports = Logger;
+  }
+});
+
+// src/browser.ts
+import inspect from "object-inspect";
+var require_browser = __commonJS({
+  "src/browser.ts"(exports, module) {
+    var import_shared = __toESM(require_shared());
+    import_shared.default.format("o", (value, target) => {
+      return inspect(value, { depth: Infinity }).replace(/\s*\n\s*/g, " ");
+    });
+    module.exports = import_shared.default;
+  }
+});
+export default require_browser();