colorino 0.9.0 → 0.10.0

package/dist/browser.bundle.mjs

@@ -0,0 +1,924 @@
+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 || {});
+
+function isConsoleMethod(level) {
+  return ["log", "info", "warn", "error", "trace", "debug"].includes(level);
+}
+
+class Colorino {
+  constructor(_palette, _validator, _browserColorSupportDetector, _nodeColorSupportDetector, _options = {}) {
+    this._palette = _palette;
+    this._validator = _validator;
+    this._browserColorSupportDetector = _browserColorSupportDetector;
+    this._nodeColorSupportDetector = _nodeColorSupportDetector;
+    this._options = _options;
+    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();
+    }
+  }
+  _alreadyWarned = false;
+  _colorLevel;
+  isBrowser;
+  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);
+  }
+  _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(
+      "[Colorino] 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 = 5) {
+    const seen = /* @__PURE__ */ new WeakSet();
+    const sanitize = (val, currentDepth) => {
+      if (val === null || typeof val !== "object") return val;
+      if (seen.has(val)) return "[Circular]";
+      seen.add(val);
+      if (currentDepth >= maxDepth) return "[Object]";
+      if (Array.isArray(val)) {
+        return val.map((item) => sanitize(item, currentDepth + 1));
+      }
+      const result = {};
+      for (const key in val) {
+        result[key] = sanitize(
+          val[key],
+          currentDepth + 1
+        );
+      }
+      return result;
+    };
+    return JSON.stringify(sanitize(value, 0), null, 2);
+  }
+  _processArgs(args) {
+    const processedArgs = [];
+    let previousWasObject = false;
+    for (const arg of args) {
+      const isFormattableObject = arg !== null && typeof arg === "object" && typeof arg !== "string" && !(arg instanceof Error);
+      const isError = arg instanceof Error;
+      if (isFormattableObject) {
+        processedArgs.push(`
+${this._formatValue(arg)}`);
+        previousWasObject = true;
+      } else if (isError) {
+        processedArgs.push("\n", this._cleanErrorStack(arg));
+        previousWasObject = true;
+      } else {
+        if (typeof arg === "string" && previousWasObject) {
+          processedArgs.push(`
+${arg}`);
+        } else {
+          processedArgs.push(arg);
+        }
+        previousWasObject = false;
+      }
+    }
+    return processedArgs;
+  }
+  _applyBrowserColors(consoleMethod, args) {
+    const hex = this._palette[consoleMethod];
+    if (typeof args[0] === "string") {
+      return [`%c${args[0]}`, `color:${hex}`, ...args.slice(1)];
+    }
+    return args;
+  }
+  _applyNodeColors(consoleMethod, args) {
+    const hex = this._palette[consoleMethod];
+    let ansiCode;
+    switch (this._colorLevel) {
+      case ColorLevel.TRUECOLOR: {
+        const [r, g, b] = colorConverter.hex.toRgb(hex);
+        ansiCode = `\x1B[38;2;${r};${g};${b}m`;
+        break;
+      }
+      case ColorLevel.ANSI256: {
+        const code = colorConverter.hex.toAnsi256(hex);
+        ansiCode = `\x1B[38;5;${code}m`;
+        break;
+      }
+      case ColorLevel.ANSI:
+      default: {
+        const code = colorConverter.hex.toAnsi16(hex);
+        ansiCode = `\x1B[${code}m`;
+        break;
+      }
+    }
+    const coloredArgs = [...args];
+    const firstStringIndex = coloredArgs.findIndex(
+      (arg) => typeof arg === "string"
+    );
+    if (firstStringIndex !== -1) {
+      coloredArgs[firstStringIndex] = `${ansiCode}${coloredArgs[firstStringIndex]}\x1B[0m`;
+    }
+    return coloredArgs;
+  }
+  _output(consoleMethod, args) {
+    if (consoleMethod === "trace") {
+      this._printCleanTrace(args, consoleMethod);
+    } else {
+      console[consoleMethod](...args);
+    }
+  }
+  _out(level, args) {
+    const consoleMethod = 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.includes("colorino.js") && !line.includes("Colorino._out") && !line.includes("Colorino.error") && !line.includes("Colorino.warn") && !line.includes("Colorino.debug") && !line.includes("Colorino.info") && !line.includes("Colorino.log") && !line.includes("Colorino.trace") && !line.includes("Colorino._cleanErrorStack") && !line.includes("Colorino._printCleanTrace") && !line.includes("Colorino._filterStack")
+    ).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, method) {
+    const error = new Error();
+    if (error.stack) {
+      const cleanStack = this._filterStack(error.stack);
+      console[method](...args, `
+${cleanStack}`);
+    } else {
+      console[method](...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 ColorinoError extends Error {
+  constructor(message) {
+    super(message);
+    this.name = "ColorinoError";
+    Object.setPrototypeOf(this, ColorinoError.prototype);
+  }
+}
+
+class InputValidator {
+  validateHex(hex) {
+    const trimmedHex = hex.trim();
+    const isHexValid = /^#[0-9A-F]{6}$/i.test(trimmedHex);
+    if (!isHexValid) {
+      return err(new ColorinoError(`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);
+  }
+}
+
+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 minimalDarkPalette = {
+  log: "#ffffff",
+  info: "#ffffff",
+  warn: "#ffffff",
+  error: "#ffffff",
+  debug: "#ffffff",
+  trace: "#ffffff"
+};
+const minimalLightPalette = {
+  log: "#000000",
+  info: "#000000",
+  warn: "#000000",
+  error: "#000000",
+  debug: "#000000",
+  trace: "#000000"
+};
+
+const themePalettes = {
+  "catppuccin-mocha": catppuccinMochaPalette,
+  "catppuccin-latte": catppuccinLattePalette,
+  dracula: draculaPalette,
+  "github-light": githubLightPalette,
+  "minimal-dark": minimalDarkPalette,
+  "minimal-light": minimalLightPalette
+};
+const defaultDarkTheme = "minimal-dark";
+const defaultLightTheme = "minimal-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 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(palette = {}, 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, ...palette };
+  return new Colorino(
+    finalPalette,
+    validator,
+    browserDetector,
+    // Always use browser detector
+    void 0,
+    // Node detector is never available
+    options
+  );
+}
+const colorino = createColorino();
+
+export { colorino, createColorino, themePalettes };