custom-electron-titlebar 4.2.8 → 4.4.1

package/main/index.js

@@ -1,202 +1,820 @@
 "use strict";
-
-/* ---------------------------------------------------------------------------------------------
- *  Copyright (c) AlexTorresDev. All rights reserved.
- *  Licensed under the MIT License. See License.txt in the project root for license information.
- *-------------------------------------------------------------------------------------------- */
-var __importDefault = this && this.__importDefault || function (mod) {
-  return mod && mod.__esModule ? mod : {
-    "default": mod
-  };
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
 };
-Object.defineProperty(exports, "__esModule", {
-  value: true
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/main/index.ts
+var main_exports = {};
+__export(main_exports, {
+  attachTitlebarToWindow: () => attach_titlebar_to_window_default,
+  setupTitlebar: () => setup_titlebar_default,
+  setupTitlebarAndAttachToWindow: () => setupTitlebarAndAttachToWindow
 });
-exports.attachTitlebarToWindow = exports.setupTitlebar = void 0;
-const attach_titlebar_to_window_1 = _get__("__importDefault")(require("./attach-titlebar-to-window"));
-exports.attachTitlebarToWindow = _get__("attach_titlebar_to_window_1").default;
-const setup_titlebar_1 = _get__("__importDefault")(require("./setup-titlebar"));
-exports.setupTitlebar = _get__("setup_titlebar_1").default;
-function _getGlobalObject() {
-  try {
-    if (!!global) {
-      return global;
-    }
-  } catch (e) {
-    try {
-      if (!!window) {
-        return window;
+module.exports = __toCommonJS(main_exports);
+
+// src/base/common/color.ts
+function roundFloat(number, decimalPoints) {
+  const decimal = Math.pow(10, decimalPoints);
+  return Math.round(number * decimal) / decimal;
+}
+var RGBA = class {
+  constructor(r, g, b, a = 1) {
+    this.r = Math.min(255, Math.max(0, r)) | 0;
+    this.g = Math.min(255, Math.max(0, g)) | 0;
+    this.b = Math.min(255, Math.max(0, b)) | 0;
+    this.a = roundFloat(Math.max(Math.min(1, a), 0), 3);
+  }
+  static equals(a, b) {
+    return a.r === b.r && a.g === b.g && a.b === b.b && a.a === b.a;
+  }
+};
+var HSLA = class _HSLA {
+  constructor(h, s, l, a) {
+    this.h = Math.max(Math.min(360, h), 0) | 0;
+    this.s = roundFloat(Math.max(Math.min(1, s), 0), 3);
+    this.l = roundFloat(Math.max(Math.min(1, l), 0), 3);
+    this.a = roundFloat(Math.max(Math.min(1, a), 0), 3);
+  }
+  static equals(a, b) {
+    return a.h === b.h && a.s === b.s && a.l === b.l && a.a === b.a;
+  }
+  /**
+   * Converts an RGB color value to HSL. Conversion formula
+   * adapted from http://en.wikipedia.org/wiki/HSL_color_space.
+   * Assumes r, g, and b are contained in the set [0, 255] and
+   * returns h in the set [0, 360], s, and l in the set [0, 1].
+   */
+  static fromRGBA(rgba) {
+    const r = rgba.r / 255;
+    const g = rgba.g / 255;
+    const b = rgba.b / 255;
+    const a = rgba.a;
+    const max = Math.max(r, g, b);
+    const min = Math.min(r, g, b);
+    let h = 0;
+    let s = 0;
+    const l = (min + max) / 2;
+    const chroma = max - min;
+    if (chroma > 0) {
+      s = Math.min(l <= 0.5 ? chroma / (2 * l) : chroma / (2 - 2 * l), 1);
+      switch (max) {
+        case r:
+          h = (g - b) / chroma + (g < b ? 6 : 0);
+          break;
+        case g:
+          h = (b - r) / chroma + 2;
+          break;
+        case b:
+          h = (r - g) / chroma + 4;
+          break;
       }
-    } catch (e) {
-      return this;
+      h *= 60;
+      h = Math.round(h);
     }
+    return new _HSLA(h, s, l, a);
   }
-}
-;
-var _RewireModuleId__ = null;
-function _getRewireModuleId__() {
-  if (_RewireModuleId__ === null) {
-    let globalVariable = _getGlobalObject();
-    if (!globalVariable.__$$GLOBAL_REWIRE_NEXT_MODULE_ID__) {
-      globalVariable.__$$GLOBAL_REWIRE_NEXT_MODULE_ID__ = 0;
+  static _hue2rgb(p, q, t) {
+    if (t < 0) {
+      t += 1;
     }
-    _RewireModuleId__ = __$$GLOBAL_REWIRE_NEXT_MODULE_ID__++;
+    if (t > 1) {
+      t -= 1;
+    }
+    if (t < 1 / 6) {
+      return p + (q - p) * 6 * t;
+    }
+    if (t < 1 / 2) {
+      return q;
+    }
+    if (t < 2 / 3) {
+      return p + (q - p) * (2 / 3 - t) * 6;
+    }
+    return p;
   }
-  return _RewireModuleId__;
-}
-function _getRewireRegistry__() {
-  let theGlobalVariable = _getGlobalObject();
-  if (!theGlobalVariable.__$$GLOBAL_REWIRE_REGISTRY__) {
-    theGlobalVariable.__$$GLOBAL_REWIRE_REGISTRY__ = Object.create(null);
+  /**
+   * Converts an HSL color value to RGB. Conversion formula
+   * adapted from http://en.wikipedia.org/wiki/HSL_color_space.
+   * Assumes h in the set [0, 360] s, and l are contained in the set [0, 1] and
+   * returns r, g, and b in the set [0, 255].
+   */
+  static toRGBA(hsla) {
+    const h = hsla.h / 360;
+    const { s, l, a } = hsla;
+    let r, g, b;
+    if (s === 0) {
+      r = g = b = l;
+    } else {
+      const q = l < 0.5 ? l * (1 + s) : l + s - l * s;
+      const p = 2 * l - q;
+      r = _HSLA._hue2rgb(p, q, h + 1 / 3);
+      g = _HSLA._hue2rgb(p, q, h);
+      b = _HSLA._hue2rgb(p, q, h - 1 / 3);
+    }
+    return new RGBA(Math.round(r * 255), Math.round(g * 255), Math.round(b * 255), a);
   }
-  return theGlobalVariable.__$$GLOBAL_REWIRE_REGISTRY__;
-}
-function _getRewiredData__() {
-  let moduleId = _getRewireModuleId__();
-  let registry = _getRewireRegistry__();
-  let rewireData = registry[moduleId];
-  if (!rewireData) {
-    registry[moduleId] = Object.create(null);
-    rewireData = registry[moduleId];
-  }
-  return rewireData;
-}
-(function registerResetAll() {
-  let theGlobalVariable = _getGlobalObject();
-  if (!theGlobalVariable['__rewire_reset_all__']) {
-    theGlobalVariable['__rewire_reset_all__'] = function () {
-      theGlobalVariable.__$$GLOBAL_REWIRE_REGISTRY__ = Object.create(null);
-    };
-  }
-})();
-var INTENTIONAL_UNDEFINED = '__INTENTIONAL_UNDEFINED__';
-let _RewireAPI__ = {};
-(function () {
-  function addPropertyToAPIObject(name, value) {
-    Object.defineProperty(_RewireAPI__, name, {
-      value: value,
-      enumerable: false,
-      configurable: true
-    });
+};
+var HSVA = class _HSVA {
+  constructor(h, s, v, a) {
+    this.h = Math.max(Math.min(360, h), 0) | 0;
+    this.s = roundFloat(Math.max(Math.min(1, s), 0), 3);
+    this.v = roundFloat(Math.max(Math.min(1, v), 0), 3);
+    this.a = roundFloat(Math.max(Math.min(1, a), 0), 3);
+  }
+  static equals(a, b) {
+    return a.h === b.h && a.s === b.s && a.v === b.v && a.a === b.a;
   }
-  addPropertyToAPIObject('__get__', _get__);
-  addPropertyToAPIObject('__GetDependency__', _get__);
-  addPropertyToAPIObject('__Rewire__', _set__);
-  addPropertyToAPIObject('__set__', _set__);
-  addPropertyToAPIObject('__reset__', _reset__);
-  addPropertyToAPIObject('__ResetDependency__', _reset__);
-  addPropertyToAPIObject('__with__', _with__);
-})();
-function _get__(variableName) {
-  let rewireData = _getRewiredData__();
-  if (rewireData[variableName] === undefined) {
-    return _get_original__(variableName);
-  } else {
-    var value = rewireData[variableName];
-    if (value === INTENTIONAL_UNDEFINED) {
-      return undefined;
+  // from http://www.rapidtables.com/convert/color/rgb-to-hsv.htm
+  static fromRGBA(rgba) {
+    const r = rgba.r / 255;
+    const g = rgba.g / 255;
+    const b = rgba.b / 255;
+    const cmax = Math.max(r, g, b);
+    const cmin = Math.min(r, g, b);
+    const delta = cmax - cmin;
+    const s = cmax === 0 ? 0 : delta / cmax;
+    let m;
+    if (delta === 0) {
+      m = 0;
+    } else if (cmax === r) {
+      m = ((g - b) / delta % 6 + 6) % 6;
+    } else if (cmax === g) {
+      m = (b - r) / delta + 2;
     } else {
-      return value;
+      m = (r - g) / delta + 4;
+    }
+    return new _HSVA(Math.round(m * 60), s, cmax, rgba.a);
+  }
+  // from http://www.rapidtables.com/convert/color/hsv-to-rgb.htm
+  static toRGBA(hsva) {
+    const { h, s, v, a } = hsva;
+    const c = v * s;
+    const x = c * (1 - Math.abs(h / 60 % 2 - 1));
+    const m = v - c;
+    let [r, g, b] = [0, 0, 0];
+    if (h < 60) {
+      r = c;
+      g = x;
+    } else if (h < 120) {
+      r = x;
+      g = c;
+    } else if (h < 180) {
+      g = c;
+      b = x;
+    } else if (h < 240) {
+      g = x;
+      b = c;
+    } else if (h < 300) {
+      r = x;
+      b = c;
+    } else if (h < 360) {
+      r = c;
+      b = x;
+    }
+    r = Math.round((r + m) * 255);
+    g = Math.round((g + m) * 255);
+    b = Math.round((b + m) * 255);
+    return new RGBA(r, g, b, a);
+  }
+};
+var _Color = class _Color {
+  static fromHex(hex) {
+    return _Color.Format.CSS.parseHex(hex) || _Color.RED;
+  }
+  get hsla() {
+    if (this._hsla) {
+      return this._hsla;
+    } else {
+      return HSLA.fromRGBA(this.rgba);
+    }
+  }
+  get hsva() {
+    if (this._hsva) {
+      return this._hsva;
+    }
+    return HSVA.fromRGBA(this.rgba);
+  }
+  constructor(arg) {
+    if (!arg) {
+      throw new Error("Color needs a value");
+    } else if (arg instanceof RGBA) {
+      this.rgba = arg;
+    } else if (arg instanceof HSLA) {
+      this._hsla = arg;
+      this.rgba = HSLA.toRGBA(arg);
+    } else if (arg instanceof HSVA) {
+      this._hsva = arg;
+      this.rgba = HSVA.toRGBA(arg);
+    } else {
+      throw new Error("Invalid color ctor argument");
+    }
+  }
+  equals(other) {
+    return !!other && RGBA.equals(this.rgba, other.rgba) && HSLA.equals(this.hsla, other.hsla) && HSVA.equals(this.hsva, other.hsva);
+  }
+  /**
+   * http://www.w3.org/TR/WCAG20/#relativeluminancedef
+   * Returns the number in the set [0, 1]. O => Darkest Black. 1 => Lightest white.
+   */
+  getRelativeLuminance() {
+    const R = _Color._relativeLuminanceForComponent(this.rgba.r);
+    const G = _Color._relativeLuminanceForComponent(this.rgba.g);
+    const B = _Color._relativeLuminanceForComponent(this.rgba.b);
+    const luminance = 0.2126 * R + 0.7152 * G + 0.0722 * B;
+    return roundFloat(luminance, 4);
+  }
+  static _relativeLuminanceForComponent(color) {
+    const c = color / 255;
+    return c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+  }
+  /**
+   * http://www.w3.org/TR/WCAG20/#contrast-ratiodef
+   * Returns the contrast ration number in the set [1, 21].
+   */
+  getContrastRatio(another) {
+    const lum1 = this.getRelativeLuminance();
+    const lum2 = another.getRelativeLuminance();
+    return lum1 > lum2 ? (lum1 + 0.05) / (lum2 + 0.05) : (lum2 + 0.05) / (lum1 + 0.05);
+  }
+  /**
+   *	http://24ways.org/2010/calculating-color-contrast
+   *  Return 'true' if darker color otherwise 'false'
+   */
+  isDarker() {
+    const yiq = (this.rgba.r * 299 + this.rgba.g * 587 + this.rgba.b * 114) / 1e3;
+    return yiq < 128;
+  }
+  /**
+   *	http://24ways.org/2010/calculating-color-contrast
+   *  Return 'true' if lighter color otherwise 'false'
+   */
+  isLighter() {
+    const yiq = (this.rgba.r * 299 + this.rgba.g * 587 + this.rgba.b * 114) / 1e3;
+    return yiq >= 128;
+  }
+  isLighterThan(another) {
+    const lum1 = this.getRelativeLuminance();
+    const lum2 = another.getRelativeLuminance();
+    return lum1 > lum2;
+  }
+  isDarkerThan(another) {
+    const lum1 = this.getRelativeLuminance();
+    const lum2 = another.getRelativeLuminance();
+    return lum1 < lum2;
+  }
+  lighten(factor) {
+    return new _Color(new HSLA(this.hsla.h, this.hsla.s, this.hsla.l + this.hsla.l * factor, this.hsla.a));
+  }
+  darken(factor) {
+    return new _Color(new HSLA(this.hsla.h, this.hsla.s, this.hsla.l - this.hsla.l * factor, this.hsla.a));
+  }
+  transparent(factor) {
+    const { r, g, b, a } = this.rgba;
+    return new _Color(new RGBA(r, g, b, a * factor));
+  }
+  isTransparent() {
+    return this.rgba.a === 0;
+  }
+  isOpaque() {
+    return this.rgba.a === 1;
+  }
+  opposite() {
+    return new _Color(new RGBA(255 - this.rgba.r, 255 - this.rgba.g, 255 - this.rgba.b, this.rgba.a));
+  }
+  blend(c) {
+    const rgba = c.rgba;
+    const thisA = this.rgba.a;
+    const colorA = rgba.a;
+    const a = thisA + colorA * (1 - thisA);
+    if (a < 1e-6) {
+      return _Color.TRANSPARENT;
+    }
+    const r = this.rgba.r * thisA / a + rgba.r * colorA * (1 - thisA) / a;
+    const g = this.rgba.g * thisA / a + rgba.g * colorA * (1 - thisA) / a;
+    const b = this.rgba.b * thisA / a + rgba.b * colorA * (1 - thisA) / a;
+    return new _Color(new RGBA(r, g, b, a));
+  }
+  flatten(...backgrounds) {
+    const background = backgrounds.reduceRight((accumulator, color) => {
+      return _Color._flatten(color, accumulator);
+    });
+    return _Color._flatten(this, background);
+  }
+  static _flatten(foreground, background) {
+    const backgroundAlpha = 1 - foreground.rgba.a;
+    return new _Color(new RGBA(
+      backgroundAlpha * background.rgba.r + foreground.rgba.a * foreground.rgba.r,
+      backgroundAlpha * background.rgba.g + foreground.rgba.a * foreground.rgba.g,
+      backgroundAlpha * background.rgba.b + foreground.rgba.a * foreground.rgba.b
+    ));
+  }
+  toString() {
+    return "" + _Color.Format.CSS.format(this);
+  }
+  static getLighterColor(of, relative, factor) {
+    if (of.isLighterThan(relative)) {
+      return of;
+    }
+    factor = factor || 0.5;
+    const lum1 = of.getRelativeLuminance();
+    const lum2 = relative.getRelativeLuminance();
+    factor = factor * (lum2 - lum1) / lum2;
+    return of.lighten(factor);
+  }
+  static getDarkerColor(of, relative, factor) {
+    if (of.isDarkerThan(relative)) {
+      return of;
     }
+    factor = factor || 0.5;
+    const lum1 = of.getRelativeLuminance();
+    const lum2 = relative.getRelativeLuminance();
+    factor = factor * (lum1 - lum2) / lum1;
+    return of.darken(factor);
   }
+};
+_Color.WHITE = new _Color(new RGBA(255, 255, 255, 1));
+_Color.BLACK = new _Color(new RGBA(0, 0, 0, 1));
+_Color.RED = new _Color(new RGBA(255, 0, 0, 1));
+_Color.BLUE = new _Color(new RGBA(0, 0, 255, 1));
+_Color.GREEN = new _Color(new RGBA(0, 255, 0, 1));
+_Color.CYAN = new _Color(new RGBA(0, 255, 255, 1));
+_Color.LIGHTGREY = new _Color(new RGBA(211, 211, 211, 1));
+_Color.TRANSPARENT = new _Color(new RGBA(0, 0, 0, 0));
+var Color = _Color;
+((Color2) => {
+  let Format;
+  ((Format2) => {
+    let CSS;
+    ((CSS2) => {
+      function formatRGB(color) {
+        if (color.rgba.a === 1) {
+          return `rgb(${color.rgba.r}, ${color.rgba.g}, ${color.rgba.b})`;
+        }
+        return Color2.Format.CSS.formatRGBA(color);
+      }
+      CSS2.formatRGB = formatRGB;
+      function formatRGBA(color) {
+        return `rgba(${color.rgba.r}, ${color.rgba.g}, ${color.rgba.b}, ${+color.rgba.a.toFixed(2)})`;
+      }
+      CSS2.formatRGBA = formatRGBA;
+      function formatHSL(color) {
+        if (color.hsla.a === 1) {
+          return `hsl(${color.hsla.h}, ${(color.hsla.s * 100).toFixed(2)}%, ${(color.hsla.l * 100).toFixed(2)}%)`;
+        }
+        return Color2.Format.CSS.formatHSLA(color);
+      }
+      CSS2.formatHSL = formatHSL;
+      function formatHSLA(color) {
+        return `hsla(${color.hsla.h}, ${(color.hsla.s * 100).toFixed(2)}%, ${(color.hsla.l * 100).toFixed(2)}%, ${color.hsla.a.toFixed(2)})`;
+      }
+      CSS2.formatHSLA = formatHSLA;
+      function _toTwoDigitHex(n) {
+        const r = n.toString(16);
+        return r.length !== 2 ? "0" + r : r;
+      }
+      function formatHex(color) {
+        return `#${_toTwoDigitHex(color.rgba.r)}${_toTwoDigitHex(color.rgba.g)}${_toTwoDigitHex(color.rgba.b)}`;
+      }
+      CSS2.formatHex = formatHex;
+      function formatHexA(color, compact = false) {
+        if (compact && color.rgba.a === 1) {
+          return Color2.Format.CSS.formatHex(color);
+        }
+        return `#${_toTwoDigitHex(color.rgba.r)}${_toTwoDigitHex(color.rgba.g)}${_toTwoDigitHex(color.rgba.b)}${_toTwoDigitHex(Math.round(color.rgba.a * 255))}`;
+      }
+      CSS2.formatHexA = formatHexA;
+      function format(color) {
+        if (!color) {
+          return null;
+        }
+        if (color.isOpaque()) {
+          return Color2.Format.CSS.formatHex(color);
+        }
+        return Color2.Format.CSS.formatRGBA(color);
+      }
+      CSS2.format = format;
+      function parseHex(hex) {
+        if (!hex) {
+          return null;
+        }
+        const length = hex.length;
+        if (length === 0) {
+          return null;
+        }
+        if (hex.charCodeAt(0) !== 35 /* Hash */) {
+          return null;
+        }
+        if (length === 7) {
+          const r = 16 * _parseHexDigit(hex.charCodeAt(1)) + _parseHexDigit(hex.charCodeAt(2));
+          const g = 16 * _parseHexDigit(hex.charCodeAt(3)) + _parseHexDigit(hex.charCodeAt(4));
+          const b = 16 * _parseHexDigit(hex.charCodeAt(5)) + _parseHexDigit(hex.charCodeAt(6));
+          return new Color2(new RGBA(r, g, b, 1));
+        }
+        if (length === 9) {
+          const r = 16 * _parseHexDigit(hex.charCodeAt(1)) + _parseHexDigit(hex.charCodeAt(2));
+          const g = 16 * _parseHexDigit(hex.charCodeAt(3)) + _parseHexDigit(hex.charCodeAt(4));
+          const b = 16 * _parseHexDigit(hex.charCodeAt(5)) + _parseHexDigit(hex.charCodeAt(6));
+          const a = 16 * _parseHexDigit(hex.charCodeAt(7)) + _parseHexDigit(hex.charCodeAt(8));
+          return new Color2(new RGBA(r, g, b, a / 255));
+        }
+        if (length === 4) {
+          const r = _parseHexDigit(hex.charCodeAt(1));
+          const g = _parseHexDigit(hex.charCodeAt(2));
+          const b = _parseHexDigit(hex.charCodeAt(3));
+          return new Color2(new RGBA(16 * r + r, 16 * g + g, 16 * b + b));
+        }
+        if (length === 5) {
+          const r = _parseHexDigit(hex.charCodeAt(1));
+          const g = _parseHexDigit(hex.charCodeAt(2));
+          const b = _parseHexDigit(hex.charCodeAt(3));
+          const a = _parseHexDigit(hex.charCodeAt(4));
+          return new Color2(new RGBA(16 * r + r, 16 * g + g, 16 * b + b, (16 * a + a) / 255));
+        }
+        return null;
+      }
+      CSS2.parseHex = parseHex;
+      function _parseHexDigit(charCode) {
+        switch (charCode) {
+          case 48 /* Digit0 */:
+            return 0;
+          case 49 /* Digit1 */:
+            return 1;
+          case 50 /* Digit2 */:
+            return 2;
+          case 51 /* Digit3 */:
+            return 3;
+          case 52 /* Digit4 */:
+            return 4;
+          case 53 /* Digit5 */:
+            return 5;
+          case 54 /* Digit6 */:
+            return 6;
+          case 55 /* Digit7 */:
+            return 7;
+          case 56 /* Digit8 */:
+            return 8;
+          case 57 /* Digit9 */:
+            return 9;
+          case 97 /* a */:
+            return 10;
+          case 65 /* A */:
+            return 10;
+          case 98 /* b */:
+            return 11;
+          case 66 /* B */:
+            return 11;
+          case 99 /* c */:
+            return 12;
+          case 67 /* C */:
+            return 12;
+          case 100 /* d */:
+            return 13;
+          case 68 /* D */:
+            return 13;
+          case 101 /* e */:
+            return 14;
+          case 69 /* E */:
+            return 14;
+          case 102 /* f */:
+            return 15;
+          case 70 /* F */:
+            return 15;
+        }
+        return 0;
+      }
+    })(CSS = Format2.CSS || (Format2.CSS = {}));
+  })(Format = Color2.Format || (Color2.Format = {}));
+})(Color || (Color = {}));
+
+// src/base/common/platform.ts
+var _isWindows = false;
+var _isMacintosh = false;
+var _isLinux = false;
+var _isFreeBSD = false;
+var _isNative = false;
+var _isWeb = false;
+var isElectronRenderer = typeof process !== "undefined" && typeof process.versions !== "undefined" && typeof process.versions.electron !== "undefined" && process.type === "renderer";
+if (typeof navigator === "object" && !isElectronRenderer) {
+  const userAgent = navigator.userAgent;
+  _isWindows = userAgent.indexOf("Windows") >= 0;
+  _isMacintosh = userAgent.indexOf("Macintosh") >= 0;
+  _isLinux = userAgent.indexOf("Linux") >= 0;
+  _isFreeBSD = userAgent.indexOf("FreeBSD") >= 0;
+  _isWeb = true;
+} else if (typeof process === "object") {
+  _isWindows = process.platform === "win32";
+  _isMacintosh = process.platform === "darwin";
+  _isLinux = process.platform === "linux";
+  _isFreeBSD = process.platform === "freebsd";
+  _isNative = true;
 }
-function _get_original__(variableName) {
-  switch (variableName) {
-    case "__importDefault":
-      return __importDefault;
-    case "attach_titlebar_to_window_1":
-      return attach_titlebar_to_window_1;
-    case "setup_titlebar_1":
-      return setup_titlebar_1;
-  }
-  return undefined;
+var _platform = 0 /* Web */;
+if (_isNative) {
+  if (_isMacintosh) {
+    _platform = 1 /* Mac */;
+  } else if (_isWindows) {
+    _platform = 4 /* Windows */;
+  } else if (_isLinux) {
+    _platform = 2 /* Linux */;
+  } else if (_isFreeBSD) {
+    _platform = 3 /* FreeBSD */;
+  }
 }
-function _assign__(variableName, value) {
-  let rewireData = _getRewiredData__();
-  if (rewireData[variableName] === undefined) {
-    return _set_original__(variableName, value);
-  } else {
-    return rewireData[variableName] = value;
+var isMacintosh = _isMacintosh;
+var _wl = _isWindows ? 1 /* Windows */ : 3 /* Linux */ | 4 /* FreeBSD */;
+
+// src/consts.ts
+var INACTIVE_FOREGROUND_DARK = Color.fromHex("#222222");
+var ACTIVE_FOREGROUND_DARK = Color.fromHex("#333333");
+var INACTIVE_FOREGROUND = Color.fromHex("#EEEEEE");
+var ACTIVE_FOREGROUND = Color.fromHex("#FFFFFF");
+var DEFAULT_ITEM_SELECTOR = Color.fromHex("#0000001F");
+var IS_MAC_BIGSUR_OR_LATER = isMacintosh && parseInt(process.getSystemVersion().split(".")[0]) >= 11;
+var WINDOW_MIN_WIDTH = 400;
+var WINDOW_MIN_HEIGHT = 270;
+
+// src/main/attach-titlebar-to-window.ts
+var attachedWindows = /* @__PURE__ */ new WeakMap();
+var attach_titlebar_to_window_default = (browserWindow, options = {}) => {
+  const existingDetach = attachedWindows.get(browserWindow);
+  if (existingDetach) {
+    return existingDetach;
   }
+  const [windowWidth, windowHeight] = browserWindow.getSize();
+  const minWidth = Number.isFinite(options.minWidth) ? Math.max(0, Math.floor(options.minWidth)) : Math.max(windowWidth, WINDOW_MIN_WIDTH);
+  const minHeight = Number.isFinite(options.minHeight) ? Math.max(0, Math.floor(options.minHeight)) : Math.max(windowHeight, WINDOW_MIN_HEIGHT);
+  browserWindow.setMinimumSize(minWidth, minHeight);
+  const emit = (channel, value) => {
+    if (!browserWindow.isDestroyed()) {
+      browserWindow.webContents.send(channel, value);
+    }
+  };
+  const onEnterFullScreen = () => emit("window-fullscreen", true);
+  const onLeaveFullScreen = () => emit("window-fullscreen", false);
+  const onFocus = () => emit("window-focus", true);
+  const onBlur = () => emit("window-focus", false);
+  const onMaximize = () => emit("window-maximize", true);
+  const onUnmaximize = () => emit("window-maximize", false);
+  browserWindow.on("enter-full-screen", onEnterFullScreen);
+  browserWindow.on("leave-full-screen", onLeaveFullScreen);
+  browserWindow.on("focus", onFocus);
+  browserWindow.on("blur", onBlur);
+  browserWindow.on("maximize", onMaximize);
+  browserWindow.on("unmaximize", onUnmaximize);
+  const detach = () => {
+    browserWindow.removeListener("enter-full-screen", onEnterFullScreen);
+    browserWindow.removeListener("leave-full-screen", onLeaveFullScreen);
+    browserWindow.removeListener("focus", onFocus);
+    browserWindow.removeListener("blur", onBlur);
+    browserWindow.removeListener("maximize", onMaximize);
+    browserWindow.removeListener("unmaximize", onUnmaximize);
+    attachedWindows.delete(browserWindow);
+  };
+  attachedWindows.set(browserWindow, detach);
+  browserWindow.once("closed", detach);
+  return detach;
+};
+
+// src/main/setup-titlebar.ts
+var import_electron = require("electron");
+
+// src/types/ipc-contract.ts
+var IpcChannels = {
+  // Async (invoke/handle)
+  GET_WINDOW_MAXIMIZED: "window-event:is-maximized",
+  UPDATE_WINDOW_CONTROLS: "update-window-controls",
+  REQUEST_MENU_ICON: "menu-icon:request",
+  REQUEST_APPLICATION_MENU: "request-application-menu",
+  // Fire-and-forget (send/on)
+  WINDOW_EVENT: "window-event",
+  MENU_EVENT: "menu-event",
+  SET_MINIMUM_SIZE: "window-set-minimumSize",
+  GET_THEME_CONFIG: "theme-config:get"
+};
+
+// src/main/setup-titlebar.ts
+var titlebarSetupDone = false;
+var cachedThemeConfig = null;
+var setup_titlebar_default = () => {
+  if (process.type !== "browser") return;
+  if (titlebarSetupDone) return;
+  titlebarSetupDone = true;
+  import_electron.ipcMain.handle(
+    IpcChannels.REQUEST_APPLICATION_MENU,
+    async () => JSON.parse(
+      JSON.stringify(
+        import_electron.Menu.getApplicationMenu(),
+        (key, value) => key !== "commandsMap" && key !== "menu" ? value : void 0
+      )
+    )
+  );
+  import_electron.ipcMain.on(
+    IpcChannels.WINDOW_EVENT,
+    (event, eventName) => {
+      const window = import_electron.BrowserWindow.fromWebContents(event.sender);
+      if (!window) return;
+      switch (eventName) {
+        case "window-minimize":
+          window.minimize();
+          break;
+        case "window-maximize":
+          window.isMaximized() ? window.unmaximize() : window.maximize();
+          break;
+        case "window-close":
+          window.close();
+          break;
+      }
+    }
+  );
+  import_electron.ipcMain.on(
+    IpcChannels.MENU_EVENT,
+    (event, commandId) => {
+      const item = getMenuItemByCommandId(commandId, import_electron.Menu.getApplicationMenu());
+      if (item)
+        item.click(
+          void 0,
+          import_electron.BrowserWindow.fromWebContents(event.sender),
+          event.sender
+        );
+    }
+  );
+  import_electron.ipcMain.on(
+    IpcChannels.SET_MINIMUM_SIZE,
+    (event, width, height) => {
+      const window = import_electron.BrowserWindow.fromWebContents(event.sender);
+      if (!window) return;
+      const normalizedWidth = Number.isFinite(width) ? Math.max(0, Math.floor(width)) : 0;
+      const normalizedHeight = Number.isFinite(height) ? Math.max(0, Math.floor(height)) : 0;
+      window.setMinimumSize(normalizedWidth, normalizedHeight);
+    }
+  );
+  import_electron.ipcMain.handle(
+    IpcChannels.REQUEST_MENU_ICON,
+    async (event, commandId) => {
+      const item = getMenuItemByCommandId(commandId, import_electron.Menu.getApplicationMenu());
+      if (item && item.icon && typeof item.icon !== "string") {
+        return item.icon.toDataURL();
+      }
+      return null;
+    }
+  );
+  import_electron.ipcMain.handle(
+    IpcChannels.GET_WINDOW_MAXIMIZED,
+    (event) => {
+      const window = import_electron.BrowserWindow.fromWebContents(event.sender);
+      return window ? window.isMaximized() : false;
+    }
+  );
+  import_electron.ipcMain.handle(
+    IpcChannels.UPDATE_WINDOW_CONTROLS,
+    (event, args) => {
+      return updateWindowControls(event, args);
+    }
+  );
+  import_electron.ipcMain.on(
+    IpcChannels.UPDATE_WINDOW_CONTROLS,
+    (event, args) => {
+      event.returnValue = updateWindowControls(event, args);
+    }
+  );
+  import_electron.ipcMain.handle(IpcChannels.GET_THEME_CONFIG, async () => {
+    return cachedThemeConfig;
+  });
+};
+function setThemeConfig(config) {
+  cachedThemeConfig = config;
 }
-function _set_original__(variableName, _value) {
-  switch (variableName) {}
-  return undefined;
+function updateWindowControls(event, args) {
+  const window = import_electron.BrowserWindow.fromWebContents(event.sender);
+  try {
+    if (window) window.setTitleBarOverlay(args);
+    return true;
+  } catch (_) {
+    return false;
+  }
 }
-function _update_operation__(operation, variableName, prefix) {
-  var oldValue = _get__(variableName);
-  var newValue = operation === '++' ? oldValue + 1 : oldValue - 1;
-  _assign__(variableName, newValue);
-  return prefix ? newValue : oldValue;
+function getMenuItemByCommandId(commandId, menu) {
+  if (!menu) return void 0;
+  for (const item of menu.items) {
+    if (item.submenu) {
+      const submenuItem = getMenuItemByCommandId(commandId, item.submenu);
+      if (submenuItem) return submenuItem;
+    } else if (item.commandId === commandId) return item;
+  }
+  return void 0;
 }
-function _set__(variableName, value) {
-  let rewireData = _getRewiredData__();
-  if (typeof variableName === 'object') {
-    Object.keys(variableName).forEach(function (name) {
-      rewireData[name] = variableName[name];
-    });
-    return function () {
-      Object.keys(variableName).forEach(function (name) {
-        _reset__(variableName);
-      });
-    };
-  } else {
-    if (value === undefined) {
-      rewireData[variableName] = INTENTIONAL_UNDEFINED;
-    } else {
-      rewireData[variableName] = value;
-    }
-    return function () {
-      _reset__(variableName);
-    };
+
+// src/main/index.ts
+var fs = __toESM(require("fs/promises"));
+
+// src/titlebar/theme-config.ts
+var TITLEBAR_THEME_CONFIG_VERSION = 1;
+function asRecord(input) {
+  if (!input || typeof input !== "object" || Array.isArray(input)) {
+    return null;
   }
+  return input;
 }
-function _reset__(variableName) {
-  let rewireData = _getRewiredData__();
-  delete rewireData[variableName];
-  if (Object.keys(rewireData).length == 0) {
-    delete _getRewireRegistry__()[_getRewireModuleId__];
+function asString(input) {
+  if (typeof input !== "string") {
+    return void 0;
   }
-  ;
+  const value = input.trim();
+  return value.length ? value : void 0;
 }
-function _with__(object) {
-  let rewireData = _getRewiredData__();
-  var rewiredVariableNames = Object.keys(object);
-  var previousValues = {};
-  function reset() {
-    rewiredVariableNames.forEach(function (variableName) {
-      rewireData[variableName] = previousValues[variableName];
-    });
+function asFiniteNumber(input) {
+  if (typeof input !== "number" || !Number.isFinite(input)) {
+    return void 0;
   }
-  return function (callback) {
-    rewiredVariableNames.forEach(function (variableName) {
-      previousValues[variableName] = rewireData[variableName];
-      rewireData[variableName] = object[variableName];
-    });
-    let result = callback();
-    if (!!result && typeof result.then == 'function') {
-      result.then(reset).catch(reset);
-    } else {
-      reset();
-    }
-    return result;
+  return input;
+}
+function sanitizeColors(input) {
+  const source = asRecord(input);
+  if (!source) {
+    return void 0;
+  }
+  const colors = {
+    titlebar: asString(source.titlebar),
+    titlebarForeground: asString(source.titlebarForeground),
+    menuBar: asString(source.menuBar),
+    menuItemSelection: asString(source.menuItemSelection),
+    menuSeparator: asString(source.menuSeparator),
+    svg: asString(source.svg)
   };
+  const hasAnyColor = !!(colors.titlebar || colors.titlebarForeground || colors.menuBar || colors.menuItemSelection || colors.menuSeparator || colors.svg);
+  return hasAnyColor ? colors : void 0;
 }
-let _typeOfOriginalExport = typeof module.exports;
-function addNonEnumerableProperty(name, value) {
-  Object.defineProperty(module.exports, name, {
-    value: value,
-    enumerable: false,
-    configurable: true
-  });
+function normalizeThemeConfig(input) {
+  const warnings = [];
+  const source = asRecord(input);
+  if (!source) {
+    return { config: null, warnings: ["Theme config must be a JSON object."] };
+  }
+  const requestedVersion = asFiniteNumber(source.version);
+  if (requestedVersion !== void 0 && requestedVersion !== TITLEBAR_THEME_CONFIG_VERSION) {
+    warnings.push(`Theme config version ${requestedVersion} is not fully supported. Falling back to v${TITLEBAR_THEME_CONFIG_VERSION} compatible fields.`);
+  }
+  const config = {
+    fontFamily: asString(source.fontFamily),
+    fontSize: asFiniteNumber(source.fontSize),
+    colors: sanitizeColors(source.colors)
+  };
+  const hasConfig = !!(config.fontFamily || config.fontSize !== void 0 || config.colors);
+  if (!hasConfig) {
+    return { config: null, warnings: warnings.concat("No supported theme fields found in config.") };
+  }
+  return { config, warnings };
 }
-if ((_typeOfOriginalExport === 'object' || _typeOfOriginalExport === 'function') && Object.isExtensible(module.exports)) {
-  addNonEnumerableProperty('__get__', _get__);
-  addNonEnumerableProperty('__GetDependency__', _get__);
-  addNonEnumerableProperty('__Rewire__', _set__);
-  addNonEnumerableProperty('__set__', _set__);
-  addNonEnumerableProperty('__reset__', _reset__);
-  addNonEnumerableProperty('__ResetDependency__', _reset__);
-  addNonEnumerableProperty('__with__', _with__);
-  addNonEnumerableProperty('__RewireAPI__', _RewireAPI__);
-}
+
+// src/main/index.ts
+async function setupTitlebarAndAttachToWindow(browserWindow, options = {}) {
+  if (options.setupGlobal !== false) {
+    setup_titlebar_default();
+  }
+  if (options.themeConfigPath) {
+    try {
+      const raw = await fs.readFile(options.themeConfigPath, "utf8");
+      const parsed = JSON.parse(raw);
+      const normalized = normalizeThemeConfig(parsed);
+      if (normalized.warnings.length) {
+        console.warn(`[custom-electron-titlebar] Theme config from ${options.themeConfigPath}:`, normalized.warnings.join("; "));
+      }
+      if (normalized.config) {
+        setThemeConfig(normalized.config);
+      }
+    } catch (err) {
+      console.error(`[custom-electron-titlebar] Failed to load theme config from ${options.themeConfigPath}:`, err);
+    }
+  }
+  return attach_titlebar_to_window_default(browserWindow, options);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  attachTitlebarToWindow,
+  setupTitlebar,
+  setupTitlebarAndAttachToWindow
+});
+//# sourceMappingURL=index.js.map