colorino 0.13.2 → 0.14.1

package/dist/cdn.js

@@ -0,0 +1,902 @@
+(function (global, factory) {
+  typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports) :
+  typeof define === 'function' && define.amd ? define(['exports'], factory) :
+  (global = typeof globalThis !== 'undefined' ? globalThis : global || self, factory(global.colorino = {}));
+})(this, (function (exports) { 'use strict';
+
+  const ColorinoBrowserColorized = Symbol("colorino.browserColorized");
+  const ColorinoBrowserObject = Symbol("colorino.browserObject");
+
+  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 || {});
+
+  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 AbstractColorino {
+    constructor(initialPalette, _userPalette, _validator, colorLevel, _options = {}) {
+      this._userPalette = _userPalette;
+      this._validator = _validator;
+      this._options = _options;
+      this._palette = initialPalette;
+      const validatePaletteResult = this._validator.validatePalette(this._palette);
+      if (validatePaletteResult.isErr()) throw validatePaletteResult.error;
+      this._colorLevel = colorLevel;
+    }
+    _alreadyWarned = false;
+    _colorLevel;
+    _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`;
+    }
+    _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;
+      }
+      const coloredArgs = this.applyColors(consoleMethod, processedArgs);
+      this.output(consoleMethod, coloredArgs);
+    }
+    _toAnsiPrefix(_hex) {
+      return "";
+    }
+    _formatValue(value, maxDepth = this._options.maxDepth ?? 5) {
+      const seen = /* @__PURE__ */ new WeakSet();
+      const sanitizeArray = (items, depth) => {
+        return items.map((item) => sanitize(item, depth));
+      };
+      const sanitizeObject = (obj, depth) => {
+        const result = {};
+        for (const key in obj) {
+          result[key] = sanitize(obj[key], depth);
+        }
+        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);
+    }
+    _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);
+      }
+    }
+  }
+
+  class ColorinoBrowser extends AbstractColorino {
+    constructor(initialPalette, userPalette, validator, colorLevel, options = {}) {
+      super(initialPalette, userPalette, validator, colorLevel, options);
+    }
+    applyColors(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];
+    }
+    output(consoleMethod, args) {
+      console[consoleMethod](...args);
+    }
+    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)) {
+          processedArgs.push({
+            [ColorinoBrowserObject]: true,
+            value: arg
+          });
+          previousWasObject = true;
+        } else if (TypeValidator.isError(arg)) {
+          processedArgs.push("\n", this._cleanErrorStack(arg));
+          previousWasObject = true;
+        } else {
+          processedArgs.push(
+            TypeValidator.isString(arg) && previousWasObject ? `
+${arg}` : arg
+          );
+          previousWasObject = false;
+        }
+      }
+      return processedArgs;
+    }
+    isBrowser() {
+      return true;
+    }
+  }
+
+  class BrowserColorSupportDetector {
+    constructor(_window, _navigator, _overrideTheme) {
+      this._window = _window;
+      this._navigator = _navigator;
+      this._overrideTheme = _overrideTheme;
+    }
+    isBrowserEnv() {
+      return !!this._window && !!this._navigator?.userAgent;
+    }
+    getColorLevel() {
+      const isTruecolor = window.matchMedia("(color-gamut: p3)").matches;
+      if (isTruecolor) {
+        return ColorLevel.TRUECOLOR;
+      }
+      const isAnsi256 = window.matchMedia("(monochrome: 0)").matches;
+      if (isAnsi256) {
+        return ColorLevel.ANSI256;
+      }
+      return ColorLevel.ANSI;
+    }
+    getTheme() {
+      if (this._overrideTheme) {
+        return this._overrideTheme;
+      }
+      if (!this.isBrowserEnv() || typeof this._window.matchMedia !== "function") {
+        return "unknown";
+      }
+      const isDarkTheme = this._window.matchMedia(
+        "(prefers-color-scheme: dark)"
+      ).matches;
+      if (isDarkTheme) {
+        return "dark";
+      }
+      const isLightTheme = "(prefers-color-scheme: light)";
+      if (this._window.matchMedia(isLightTheme).matches) {
+        return "light";
+      }
+      return "unknown";
+    }
+  }
+
+  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);
+    }
+  }
+
+  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;
+  }
+
+  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 };
+    const colorLevel = browserDetector.isBrowserEnv() ? browserDetector.getColorLevel() ?? "UnknownEnv" : "UnknownEnv";
+    return new ColorinoBrowser(
+      finalPalette,
+      userPalette,
+      validator,
+      colorLevel,
+      options
+    );
+  }
+  const colorino = createColorino();
+
+  exports.colorino = colorino;
+  exports.createColorino = createColorino;
+  exports.themePalettes = themePalettes;
+
+}));
+//# sourceMappingURL=cdn.js.map