colorino 0.13.2 → 0.14.1

package/dist/browser.bundle.mjs

@@ -1,1007 +0,0 @@
-function hexToRgb(hex) {
-  const match = hex.toString().match(/[a-f0-9]{6}|[a-f0-9]{3}/i);
-  if (!match) {
-    return [0, 0, 0];
-  }
-  let colorString = match[0];
-  if (match[0].length === 3) {
-    colorString = [...colorString].map((char) => char + char).join("");
-  }
-  const integer = parseInt(colorString, 16);
-  const r = integer >> 16 & 255;
-  const g = integer >> 8 & 255;
-  const b = integer & 255;
-  return [r, g, b];
-}
-function rgbToAnsi256(rgb) {
-  const [r, g, b] = rgb;
-  if (r === g && g === b) {
-    if (r < 8) return 16;
-    if (r > 248) return 231;
-    return Math.round((r - 8) / 247 * 24) + 232;
-  }
-  return 16 + 36 * Math.round(r / 255 * 5) + 6 * Math.round(g / 255 * 5) + Math.round(b / 255 * 5);
-}
-function rgbToHsvValue(rgb) {
-  const r = rgb[0] / 255;
-  const g = rgb[1] / 255;
-  const b = rgb[2] / 255;
-  const v = Math.max(r, g, b);
-  return v * 100;
-}
-function rgbToAnsi16(rgb) {
-  const [r, g, b] = rgb;
-  const value = rgbToHsvValue(rgb);
-  const roundedValue = Math.round(value / 50);
-  if (roundedValue === 0) {
-    return 30;
-  }
-  let ansi = 30 + (Math.round(b / 255) << 2 | Math.round(g / 255) << 1 | Math.round(r / 255));
-  if (roundedValue === 2) {
-    ansi += 60;
-  }
-  return ansi;
-}
-const colorConverter = {
-  hex: {
-    toRgb: hexToRgb,
-    toAnsi16: (hex) => rgbToAnsi16(hexToRgb(hex)),
-    toAnsi256: (hex) => rgbToAnsi256(hexToRgb(hex))
-  }};
-
-var ColorLevel = /* @__PURE__ */ ((ColorLevel2) => {
-  ColorLevel2[ColorLevel2["NO_COLOR"] = 0] = "NO_COLOR";
-  ColorLevel2[ColorLevel2["ANSI"] = 1] = "ANSI";
-  ColorLevel2[ColorLevel2["ANSI256"] = 2] = "ANSI256";
-  ColorLevel2[ColorLevel2["TRUECOLOR"] = 3] = "TRUECOLOR";
-  return ColorLevel2;
-})(ColorLevel || {});
-
-const ColorinoBrowserColorized = Symbol("colorino.browserColorized");
-const ColorinoBrowserObject = Symbol("colorino.browserObject");
-
-const catppuccinMochaPalette = {
-  log: "#cdd6f4",
-  // Text
-  info: "#89b4fa",
-  // Blue
-  warn: "#f9e2af",
-  // Yellow
-  error: "#f38ba8",
-  // Red
-  debug: "#a6adc8",
-  // Subtext0
-  trace: "#9399b2"
-  // Subtext1
-};
-const catppuccinLattePalette = {
-  log: "#4c4f69",
-  // Text
-  info: "#1e66f5",
-  // Blue
-  warn: "#df8e1d",
-  // Yellow
-  error: "#d20f39",
-  // Red
-  debug: "#7c7f93",
-  // Subtext0
-  trace: "#8c8fa1"
-  // Subtext1
-};
-const draculaPalette = {
-  log: "#f8f8f2",
-  // Foreground
-  info: "#8be9fd",
-  // Cyan
-  warn: "#f1fa8c",
-  // Yellow
-  error: "#ff5555",
-  // Red
-  debug: "#bd93f9",
-  // Purple
-  trace: "#6272a4"
-  // Comment
-};
-const githubLightPalette = {
-  log: "#24292e",
-  // Text
-  info: "#0366d6",
-  // Blue
-  warn: "#f9a002",
-  // Yellow
-  error: "#d73a49",
-  // Red
-  debug: "#586069",
-  // Gray
-  trace: "#6a737d"
-  // Gray-light
-};
-
-const themePalettes = {
-  "catppuccin-mocha": catppuccinMochaPalette,
-  "catppuccin-latte": catppuccinLattePalette,
-  dracula: draculaPalette,
-  "github-light": githubLightPalette
-};
-const defaultDarkTheme = "dracula";
-const defaultLightTheme = "github-light";
-function isThemeName(theme) {
-  return theme in themePalettes;
-}
-
-function determineBaseTheme(themeOpt, detectedBrowserTheme) {
-  let baseThemeName;
-  if (isThemeName(themeOpt)) {
-    baseThemeName = themeOpt;
-  } else if (themeOpt === "light") {
-    baseThemeName = defaultLightTheme;
-  } else if (themeOpt === "dark") {
-    baseThemeName = defaultDarkTheme;
-  } else {
-    baseThemeName = detectedBrowserTheme === "light" ? defaultLightTheme : defaultDarkTheme;
-  }
-  return baseThemeName;
-}
-
-class TypeValidator {
-  static isNull(value) {
-    return value === null;
-  }
-  static isUndefined(value) {
-    return value === void 0;
-  }
-  static isNullOrUndefined(value) {
-    return value == null;
-  }
-  static isObject(value) {
-    return typeof value === "object" && value !== null;
-  }
-  static isString(value) {
-    return typeof value === "string" || value instanceof String;
-  }
-  static isArray(value) {
-    return Array.isArray(value);
-  }
-  static isError(value) {
-    return value instanceof Error;
-  }
-  static isBrowserColorizedArg(value) {
-    return TypeValidator.isObject(value) && ColorinoBrowserColorized in value;
-  }
-  static isBrowserObjectArg(value) {
-    return TypeValidator.isObject(value) && ColorinoBrowserObject in value;
-  }
-  static isAnsiColoredString(value) {
-    return TypeValidator.isString(value) && /\x1b\[[0-9;]*m/.test(value.toString());
-  }
-  static isFormattableObject(value) {
-    return TypeValidator.isObject(value) && !TypeValidator.isError(value) && !TypeValidator.isBrowserColorizedArg(value) && !TypeValidator.isString(value);
-  }
-  static isConsoleMethod(level) {
-    return ["log", "info", "warn", "error", "trace", "debug"].includes(level);
-  }
-}
-
-class MyColorino {
-  constructor(initialPalette, _userPalette, _validator, _browserColorSupportDetector, _nodeColorSupportDetector, _options = {}) {
-    this._userPalette = _userPalette;
-    this._validator = _validator;
-    this._browserColorSupportDetector = _browserColorSupportDetector;
-    this._nodeColorSupportDetector = _nodeColorSupportDetector;
-    this._options = _options;
-    this._palette = initialPalette;
-    this.isBrowser = !!this._browserColorSupportDetector;
-    this._colorLevel = this._detectColorSupport();
-    const validatePaletteResult = this._validator.validatePalette(this._palette);
-    if (validatePaletteResult.isErr()) throw validatePaletteResult.error;
-    if (this._colorLevel !== ColorLevel.NO_COLOR && !this._options.disableWarnings && this._colorLevel === "UnknownEnv") {
-      this._maybeWarnUser();
-    }
-    const themeOpt = this._options.theme ?? "auto";
-    if (themeOpt === "auto" && this._nodeColorSupportDetector) {
-      this._nodeColorSupportDetector.onTheme((resolvedTheme) => {
-        this._applyResolvedTheme(resolvedTheme);
-      });
-    }
-  }
-  _alreadyWarned = false;
-  _colorLevel;
-  isBrowser;
-  _palette;
-  log(...args) {
-    this._out("log", args);
-  }
-  info(...args) {
-    this._out("info", args);
-  }
-  warn(...args) {
-    this._out("warn", args);
-  }
-  error(...args) {
-    this._out("error", args);
-  }
-  trace(...args) {
-    this._out("trace", args);
-  }
-  debug(...args) {
-    this._out("debug", args);
-  }
-  colorize(text, hex) {
-    if (this._colorLevel === ColorLevel.NO_COLOR || this._colorLevel === "UnknownEnv") {
-      return text;
-    }
-    if (this.isBrowser) {
-      return {
-        [ColorinoBrowserColorized]: true,
-        text,
-        hex
-      };
-    }
-    const ansiPrefix = this._toAnsiPrefix(hex);
-    if (!ansiPrefix) {
-      return text;
-    }
-    return `${ansiPrefix}${text}\x1B[0m`;
-  }
-  _applyResolvedTheme(resolvedTheme) {
-    const themeOpt = this._options.theme ?? "auto";
-    const baseThemeName = determineBaseTheme(themeOpt, resolvedTheme);
-    const basePalette = themePalettes[baseThemeName];
-    this._palette = { ...basePalette, ...this._userPalette };
-  }
-  _detectColorSupport() {
-    if (this.isBrowser) {
-      return this._browserColorSupportDetector?.getColorLevel() ?? "UnknownEnv";
-    }
-    if (this._nodeColorSupportDetector?.isNodeEnv()) {
-      return this._nodeColorSupportDetector?.getColorLevel() ?? "UnknownEnv";
-    }
-    return "UnknownEnv";
-  }
-  _maybeWarnUser() {
-    if (this._alreadyWarned) return;
-    this._alreadyWarned = true;
-    console.warn(
-      "No ANSI color support detected in this terminal. See [https://github.com/chalk/supports-color#support-matrix](https://github.com/chalk/supports-color#support-matrix) to learn how to enable terminal color."
-    );
-  }
-  _formatValue(value, maxDepth = this._options.maxDepth ?? 5) {
-    const seen = /* @__PURE__ */ new WeakSet();
-    const sanitizeArray = (items, currentDepth) => {
-      return items.map((item) => sanitize(item, currentDepth));
-    };
-    const sanitizeObject = (obj, currentDepth) => {
-      const result = {};
-      for (const key in obj) {
-        result[key] = sanitize(obj[key], currentDepth);
-      }
-      return result;
-    };
-    const sanitize = (val, currentDepth) => {
-      if (TypeValidator.isNullOrUndefined(val) || !TypeValidator.isObject(val)) {
-        return val;
-      }
-      if (seen.has(val)) return "[Circular]";
-      seen.add(val);
-      if (currentDepth >= maxDepth) return "[Object]";
-      const nextDepth = currentDepth + 1;
-      if (TypeValidator.isArray(val)) {
-        return sanitizeArray(val, nextDepth);
-      }
-      return sanitizeObject(val, nextDepth);
-    };
-    return JSON.stringify(sanitize(value, 0), null, 2);
-  }
-  _processArgs(args) {
-    const processedArgs = [];
-    let previousWasObject = false;
-    for (const arg of args) {
-      if (TypeValidator.isBrowserColorizedArg(arg)) {
-        processedArgs.push(arg);
-        previousWasObject = false;
-        continue;
-      }
-      if (TypeValidator.isFormattableObject(arg)) {
-        if (this.isBrowser) {
-          processedArgs.push({
-            [ColorinoBrowserObject]: true,
-            value: arg
-          });
-        } else {
-          processedArgs.push(`
-${this._formatValue(arg)}`);
-        }
-        previousWasObject = true;
-      } else if (TypeValidator.isError(arg)) {
-        processedArgs.push("\n", this._cleanErrorStack(arg));
-        previousWasObject = true;
-      } else {
-        if (TypeValidator.isString(arg) && previousWasObject) {
-          processedArgs.push(`
-${arg}`);
-        } else {
-          processedArgs.push(arg);
-        }
-        previousWasObject = false;
-      }
-    }
-    return processedArgs;
-  }
-  _applyBrowserColors(consoleMethod, args) {
-    const formatParts = [];
-    const cssArgs = [];
-    const otherArgs = [];
-    const paletteHex = this._palette[consoleMethod];
-    for (const arg of args) {
-      if (TypeValidator.isBrowserColorizedArg(arg)) {
-        formatParts.push(`%c${arg.text}`);
-        cssArgs.push(`color:${arg.hex}`);
-        continue;
-      }
-      if (TypeValidator.isBrowserObjectArg(arg)) {
-        formatParts.push("%o");
-        otherArgs.push(arg.value);
-        continue;
-      }
-      if (TypeValidator.isString(arg)) {
-        formatParts.push(`%c${arg}`);
-        cssArgs.push(`color:${paletteHex}`);
-        continue;
-      }
-      formatParts.push("%o");
-      otherArgs.push(arg);
-    }
-    if (formatParts.length === 0) {
-      return args;
-    }
-    return [formatParts.join(""), ...cssArgs, ...otherArgs];
-  }
-  _toAnsiPrefix(hex) {
-    if (this._colorLevel === ColorLevel.NO_COLOR || this._colorLevel === "UnknownEnv") {
-      return "";
-    }
-    switch (this._colorLevel) {
-      case ColorLevel.TRUECOLOR: {
-        const [r, g, b] = colorConverter.hex.toRgb(hex);
-        return `\x1B[38;2;${r};${g};${b}m`;
-      }
-      case ColorLevel.ANSI256: {
-        const code = colorConverter.hex.toAnsi256(hex);
-        return `\x1B[38;5;${code}m`;
-      }
-      case ColorLevel.ANSI:
-      default: {
-        const code = colorConverter.hex.toAnsi16(hex);
-        return `\x1B[${code}m`;
-      }
-    }
-  }
-  _applyNodeColors(consoleMethod, args) {
-    const paletteHex = this._palette[consoleMethod];
-    const paletteAnsiPrefix = this._toAnsiPrefix(paletteHex);
-    if (!paletteAnsiPrefix) return args;
-    return args.map((arg) => {
-      if (!TypeValidator.isString(arg) || TypeValidator.isAnsiColoredString(arg))
-        return arg;
-      return `${paletteAnsiPrefix}${String(arg)}\x1B[0m`;
-    });
-  }
-  _output(consoleMethod, args) {
-    if (consoleMethod === "trace") this._printCleanTrace(args);
-    else console[consoleMethod](...args);
-  }
-  _out(level, args) {
-    const consoleMethod = TypeValidator.isConsoleMethod(level) ? level : "log";
-    const processedArgs = this._processArgs(args);
-    if (this._colorLevel === ColorLevel.NO_COLOR || this._colorLevel === "UnknownEnv") {
-      this._output(consoleMethod, processedArgs);
-      return;
-    }
-    if (this.isBrowser) {
-      const coloredArgs2 = this._applyBrowserColors(consoleMethod, processedArgs);
-      this._output(consoleMethod, coloredArgs2);
-      return;
-    }
-    const coloredArgs = this._applyNodeColors(consoleMethod, processedArgs);
-    this._output(consoleMethod, coloredArgs);
-  }
-  _filterStack(stack) {
-    return stack.split("\n").filter((line) => !line.match(/.*colorino.*/gi)).join("\n");
-  }
-  _cleanErrorStack(error) {
-    if (!error.stack) return error;
-    const cleanStack = this._filterStack(error.stack);
-    const cloned = Object.create(Object.getPrototypeOf(error));
-    Object.assign(cloned, error);
-    cloned.stack = cleanStack;
-    return cloned;
-  }
-  _printCleanTrace(args) {
-    const error = new Error();
-    if (error.stack) {
-      const cleanStack = this._filterStack(error.stack);
-      console.log(...args, `
-${cleanStack}`);
-    } else {
-      console.log(...args);
-    }
-  }
-}
-
-const defaultErrorConfig = {
-    withStackTrace: false,
-};
-// Custom error object
-// Context / discussion: https://github.com/supermacro/neverthrow/pull/215
-const createNeverThrowError = (message, result, config = defaultErrorConfig) => {
-    const data = result.isOk()
-        ? { type: 'Ok', value: result.value }
-        : { type: 'Err', value: result.error };
-    const maybeStack = config.withStackTrace ? new Error().stack : undefined;
-    return {
-        data,
-        message,
-        stack: maybeStack,
-    };
-};
-
-/******************************************************************************
-Copyright (c) Microsoft Corporation.
-
-Permission to use, copy, modify, and/or distribute this software for any
-purpose with or without fee is hereby granted.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
-AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
-LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
-OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
-PERFORMANCE OF THIS SOFTWARE.
-***************************************************************************** */
-/* global Reflect, Promise, SuppressedError, Symbol, Iterator */
-
-
-function __awaiter(thisArg, _arguments, P, generator) {
-    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
-    return new (P || (P = Promise))(function (resolve, reject) {
-        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
-        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
-        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
-        step((generator = generator.apply(thisArg, [])).next());
-    });
-}
-
-function __values(o) {
-    var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
-    if (m) return m.call(o);
-    if (o && typeof o.length === "number") return {
-        next: function () {
-            if (o && i >= o.length) o = void 0;
-            return { value: o && o[i++], done: !o };
-        }
-    };
-    throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
-}
-
-function __await(v) {
-    return this instanceof __await ? (this.v = v, this) : new __await(v);
-}
-
-function __asyncGenerator(thisArg, _arguments, generator) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var g = generator.apply(thisArg, _arguments || []), i, q = [];
-    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
-    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
-    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
-    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
-    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
-    function fulfill(value) { resume("next", value); }
-    function reject(value) { resume("throw", value); }
-    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
-}
-
-function __asyncDelegator(o) {
-    var i, p;
-    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
-    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: false } : f ? f(v) : v; } : f; }
-}
-
-function __asyncValues(o) {
-    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
-    var m = o[Symbol.asyncIterator], i;
-    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
-    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
-    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
-}
-
-typeof SuppressedError === "function" ? SuppressedError : function (error, suppressed, message) {
-    var e = new Error(message);
-    return e.name = "SuppressedError", e.error = error, e.suppressed = suppressed, e;
-};
-
-class ResultAsync {
-    constructor(res) {
-        this._promise = res;
-    }
-    static fromSafePromise(promise) {
-        const newPromise = promise.then((value) => new Ok(value));
-        return new ResultAsync(newPromise);
-    }
-    static fromPromise(promise, errorFn) {
-        const newPromise = promise
-            .then((value) => new Ok(value))
-            .catch((e) => new Err(errorFn(e)));
-        return new ResultAsync(newPromise);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    static fromThrowable(fn, errorFn) {
-        return (...args) => {
-            return new ResultAsync((() => __awaiter(this, void 0, void 0, function* () {
-                try {
-                    return new Ok(yield fn(...args));
-                }
-                catch (error) {
-                    return new Err(errorFn ? errorFn(error) : error);
-                }
-            }))());
-        };
-    }
-    static combine(asyncResultList) {
-        return combineResultAsyncList(asyncResultList);
-    }
-    static combineWithAllErrors(asyncResultList) {
-        return combineResultAsyncListWithAllErrors(asyncResultList);
-    }
-    map(f) {
-        return new ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
-            if (res.isErr()) {
-                return new Err(res.error);
-            }
-            return new Ok(yield f(res.value));
-        })));
-    }
-    andThrough(f) {
-        return new ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
-            if (res.isErr()) {
-                return new Err(res.error);
-            }
-            const newRes = yield f(res.value);
-            if (newRes.isErr()) {
-                return new Err(newRes.error);
-            }
-            return new Ok(res.value);
-        })));
-    }
-    andTee(f) {
-        return new ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
-            if (res.isErr()) {
-                return new Err(res.error);
-            }
-            try {
-                yield f(res.value);
-            }
-            catch (e) {
-                // Tee does not care about the error
-            }
-            return new Ok(res.value);
-        })));
-    }
-    orTee(f) {
-        return new ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
-            if (res.isOk()) {
-                return new Ok(res.value);
-            }
-            try {
-                yield f(res.error);
-            }
-            catch (e) {
-                // Tee does not care about the error
-            }
-            return new Err(res.error);
-        })));
-    }
-    mapErr(f) {
-        return new ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
-            if (res.isOk()) {
-                return new Ok(res.value);
-            }
-            return new Err(yield f(res.error));
-        })));
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
-    andThen(f) {
-        return new ResultAsync(this._promise.then((res) => {
-            if (res.isErr()) {
-                return new Err(res.error);
-            }
-            const newValue = f(res.value);
-            return newValue instanceof ResultAsync ? newValue._promise : newValue;
-        }));
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
-    orElse(f) {
-        return new ResultAsync(this._promise.then((res) => __awaiter(this, void 0, void 0, function* () {
-            if (res.isErr()) {
-                return f(res.error);
-            }
-            return new Ok(res.value);
-        })));
-    }
-    match(ok, _err) {
-        return this._promise.then((res) => res.match(ok, _err));
-    }
-    unwrapOr(t) {
-        return this._promise.then((res) => res.unwrapOr(t));
-    }
-    /**
-     * @deprecated will be removed in 9.0.0.
-     *
-     * You can use `safeTry` without this method.
-     * @example
-     * ```typescript
-     * safeTry(async function* () {
-     *   const okValue = yield* yourResult
-     * })
-     * ```
-     * Emulates Rust's `?` operator in `safeTry`'s body. See also `safeTry`.
-     */
-    safeUnwrap() {
-        return __asyncGenerator(this, arguments, function* safeUnwrap_1() {
-            return yield __await(yield __await(yield* __asyncDelegator(__asyncValues(yield __await(this._promise.then((res) => res.safeUnwrap()))))));
-        });
-    }
-    // Makes ResultAsync implement PromiseLike<Result>
-    then(successCallback, failureCallback) {
-        return this._promise.then(successCallback, failureCallback);
-    }
-    [Symbol.asyncIterator]() {
-        return __asyncGenerator(this, arguments, function* _a() {
-            const result = yield __await(this._promise);
-            if (result.isErr()) {
-                // @ts-expect-error -- This is structurally equivalent and safe
-                yield yield __await(errAsync(result.error));
-            }
-            // @ts-expect-error -- This is structurally equivalent and safe
-            return yield __await(result.value);
-        });
-    }
-}
-function errAsync(err) {
-    return new ResultAsync(Promise.resolve(new Err(err)));
-}
-
-/**
- * Short circuits on the FIRST Err value that we find
- */
-const combineResultList = (resultList) => {
-    let acc = ok([]);
-    for (const result of resultList) {
-        if (result.isErr()) {
-            acc = err(result.error);
-            break;
-        }
-        else {
-            acc.map((list) => list.push(result.value));
-        }
-    }
-    return acc;
-};
-/* This is the typesafe version of Promise.all
- *
- * Takes a list of ResultAsync<T, E> and success if all inner results are Ok values
- * or fails if one (or more) of the inner results are Err values
- */
-const combineResultAsyncList = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultList);
-/**
- * Give a list of all the errors we find
- */
-const combineResultListWithAllErrors = (resultList) => {
-    let acc = ok([]);
-    for (const result of resultList) {
-        if (result.isErr() && acc.isErr()) {
-            acc.error.push(result.error);
-        }
-        else if (result.isErr() && acc.isOk()) {
-            acc = err([result.error]);
-        }
-        else if (result.isOk() && acc.isOk()) {
-            acc.value.push(result.value);
-        }
-        // do nothing when result.isOk() && acc.isErr()
-    }
-    return acc;
-};
-const combineResultAsyncListWithAllErrors = (asyncResultList) => ResultAsync.fromSafePromise(Promise.all(asyncResultList)).andThen(combineResultListWithAllErrors);
-
-// eslint-disable-next-line @typescript-eslint/no-namespace
-var Result;
-(function (Result) {
-    /**
-     * Wraps a function with a try catch, creating a new function with the same
-     * arguments but returning `Ok` if successful, `Err` if the function throws
-     *
-     * @param fn function to wrap with ok on success or err on failure
-     * @param errorFn when an error is thrown, this will wrap the error result if provided
-     */
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    function fromThrowable(fn, errorFn) {
-        return (...args) => {
-            try {
-                const result = fn(...args);
-                return ok(result);
-            }
-            catch (e) {
-                return err(errorFn ? errorFn(e) : e);
-            }
-        };
-    }
-    Result.fromThrowable = fromThrowable;
-    function combine(resultList) {
-        return combineResultList(resultList);
-    }
-    Result.combine = combine;
-    function combineWithAllErrors(resultList) {
-        return combineResultListWithAllErrors(resultList);
-    }
-    Result.combineWithAllErrors = combineWithAllErrors;
-})(Result || (Result = {}));
-function ok(value) {
-    return new Ok(value);
-}
-function err(err) {
-    return new Err(err);
-}
-class Ok {
-    constructor(value) {
-        this.value = value;
-    }
-    isOk() {
-        return true;
-    }
-    isErr() {
-        return !this.isOk();
-    }
-    map(f) {
-        return ok(f(this.value));
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    mapErr(_f) {
-        return ok(this.value);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
-    andThen(f) {
-        return f(this.value);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
-    andThrough(f) {
-        return f(this.value).map((_value) => this.value);
-    }
-    andTee(f) {
-        try {
-            f(this.value);
-        }
-        catch (e) {
-            // Tee doesn't care about the error
-        }
-        return ok(this.value);
-    }
-    orTee(_f) {
-        return ok(this.value);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
-    orElse(_f) {
-        return ok(this.value);
-    }
-    asyncAndThen(f) {
-        return f(this.value);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
-    asyncAndThrough(f) {
-        return f(this.value).map(() => this.value);
-    }
-    asyncMap(f) {
-        return ResultAsync.fromSafePromise(f(this.value));
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    unwrapOr(_v) {
-        return this.value;
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    match(ok, _err) {
-        return ok(this.value);
-    }
-    safeUnwrap() {
-        const value = this.value;
-        /* eslint-disable-next-line require-yield */
-        return (function* () {
-            return value;
-        })();
-    }
-    _unsafeUnwrap(_) {
-        return this.value;
-    }
-    _unsafeUnwrapErr(config) {
-        throw createNeverThrowError('Called `_unsafeUnwrapErr` on an Ok', this, config);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-this-alias, require-yield
-    *[Symbol.iterator]() {
-        return this.value;
-    }
-}
-class Err {
-    constructor(error) {
-        this.error = error;
-    }
-    isOk() {
-        return false;
-    }
-    isErr() {
-        return !this.isOk();
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    map(_f) {
-        return err(this.error);
-    }
-    mapErr(f) {
-        return err(f(this.error));
-    }
-    andThrough(_f) {
-        return err(this.error);
-    }
-    andTee(_f) {
-        return err(this.error);
-    }
-    orTee(f) {
-        try {
-            f(this.error);
-        }
-        catch (e) {
-            // Tee doesn't care about the error
-        }
-        return err(this.error);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
-    andThen(_f) {
-        return err(this.error);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-explicit-any, @typescript-eslint/explicit-module-boundary-types
-    orElse(f) {
-        return f(this.error);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    asyncAndThen(_f) {
-        return errAsync(this.error);
-    }
-    asyncAndThrough(_f) {
-        return errAsync(this.error);
-    }
-    // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    asyncMap(_f) {
-        return errAsync(this.error);
-    }
-    unwrapOr(v) {
-        return v;
-    }
-    match(_ok, err) {
-        return err(this.error);
-    }
-    safeUnwrap() {
-        const error = this.error;
-        return (function* () {
-            yield err(error);
-            throw new Error('Do not use this generator out of `safeTry`');
-        })();
-    }
-    _unsafeUnwrap(config) {
-        throw createNeverThrowError('Called `_unsafeUnwrap` on an Err', this, config);
-    }
-    _unsafeUnwrapErr(_) {
-        return this.error;
-    }
-    *[Symbol.iterator]() {
-        // eslint-disable-next-line @typescript-eslint/no-this-alias
-        const self = this;
-        // @ts-expect-error -- This is structurally equivalent and safe
-        yield self;
-        // @ts-expect-error -- This is structurally equivalent and safe
-        return self;
-    }
-}
-Result.fromThrowable;
-
-class InputValidationError extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "InputValidationError";
-    Object.setPrototypeOf(this, InputValidationError.prototype);
-  }
-}
-
-class InputValidator {
-  validateHex(hex) {
-    const trimmedHex = hex.trim();
-    const isHexValid = /^#[0-9A-F]{6}$/i.test(trimmedHex);
-    if (!isHexValid) {
-      return err(new InputValidationError(`Invalid hex color: '${hex}'`));
-    }
-    return ok(true);
-  }
-  validatePalette(palette) {
-    for (const level in palette) {
-      const hex = palette[level];
-      const result = this.validateHex(hex);
-      if (result.isErr()) {
-        return err(result.error);
-      }
-    }
-    return ok(true);
-  }
-}
-
-class BrowserColorSupportDetector {
-  constructor(_window, _navigator, _overrideTheme) {
-    this._window = _window;
-    this._navigator = _navigator;
-    this._overrideTheme = _overrideTheme;
-  }
-  isBrowserEnv() {
-    return !!this._window && !!this._navigator?.userAgent;
-  }
-  getColorLevel() {
-    if (!this.isBrowserEnv()) {
-      return ColorLevel.NO_COLOR;
-    }
-    const userAgent = this._navigator.userAgent.toLowerCase();
-    if (userAgent.includes("chrome")) return ColorLevel.ANSI256;
-    if (userAgent.includes("firefox")) return ColorLevel.ANSI256;
-    return ColorLevel.ANSI256;
-  }
-  getTheme() {
-    if (this._overrideTheme) {
-      return this._overrideTheme;
-    }
-    if (!this.isBrowserEnv() || typeof this._window.matchMedia !== "function") {
-      return "unknown";
-    }
-    if (this._window.matchMedia("(prefers-color-scheme: dark)").matches) {
-      return "dark";
-    }
-    if (this._window.matchMedia("(prefers-color-scheme: light)").matches) {
-      return "light";
-    }
-    return "unknown";
-  }
-}
-
-function createColorino(userPalette = {}, options = {}) {
-  const validator = new InputValidator();
-  let detectorThemeOverride;
-  if (options.theme === "dark" || options.theme === "light") {
-    detectorThemeOverride = options.theme;
-  }
-  const browserDetector = new BrowserColorSupportDetector(
-    window,
-    navigator,
-    detectorThemeOverride
-  );
-  const detectedBrowserTheme = browserDetector.getTheme();
-  const themeOpt = options.theme ?? "auto";
-  const baseThemeName = determineBaseTheme(
-    themeOpt,
-    detectedBrowserTheme
-  );
-  const basePalette = themePalettes[baseThemeName];
-  const finalPalette = { ...basePalette, ...userPalette };
-  return new MyColorino(
-    finalPalette,
-    userPalette,
-    validator,
-    browserDetector,
-    void 0,
-    options
-  );
-}
-const colorino = createColorino();
-
-export { colorino, createColorino, themePalettes };