orcaq 1.0.20

package/.output/server/node_modules/@babel/parser/package.json

@@ -0,0 +1,50 @@
+{
+  "name": "@babel/parser",
+  "version": "7.27.0",
+  "description": "A JavaScript parser",
+  "author": "The Babel Team (https://babel.dev/team)",
+  "homepage": "https://babel.dev/docs/en/next/babel-parser",
+  "bugs": "https://github.com/babel/babel/issues?utf8=%E2%9C%93&q=is%3Aissue+label%3A%22pkg%3A+parser+%28babylon%29%22+is%3Aopen",
+  "license": "MIT",
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "babel",
+    "javascript",
+    "parser",
+    "tc39",
+    "ecmascript",
+    "@babel/parser"
+  ],
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/babel/babel.git",
+    "directory": "packages/babel-parser"
+  },
+  "main": "./lib/index.js",
+  "types": "./typings/babel-parser.d.ts",
+  "files": [
+    "bin",
+    "lib",
+    "typings/babel-parser.d.ts",
+    "index.cjs"
+  ],
+  "engines": {
+    "node": ">=6.0.0"
+  },
+  "# dependencies": "This package doesn't actually have runtime dependencies. @babel/types is only needed for type definitions.",
+  "dependencies": {
+    "@babel/types": "^7.27.0"
+  },
+  "devDependencies": {
+    "@babel/code-frame": "^7.26.2",
+    "@babel/helper-check-duplicate-nodes": "^7.25.9",
+    "@babel/helper-fixtures": "^7.26.0",
+    "@babel/helper-string-parser": "^7.25.9",
+    "@babel/helper-validator-identifier": "^7.25.9",
+    "charcodes": "^0.2.0"
+  },
+  "bin": "./bin/babel-parser.js",
+  "type": "commonjs"
+}

package/.output/server/node_modules/@iconify/utils/lib/colors/index.mjs

@@ -0,0 +1,350 @@
+import { colorKeywords } from './keywords.mjs';
+
+function rgb2hsl(rgb) {
+  const c1 = rgb.r / 255, c2 = rgb.g / 255, c3 = rgb.b / 255, kmin = Math.min(c1, Math.min(c2, c3)), kmax = Math.max(c1, Math.max(c2, c3)), l = (kmax + kmin) / 2;
+  let s, h, delta;
+  if (kmax === kmin) {
+    s = h = 0;
+  } else {
+    if (l < 0.5) {
+      s = (kmax - kmin) / (kmax + kmin);
+    } else {
+      s = (kmax - kmin) / (2 - kmax - kmin);
+    }
+    delta = kmax - kmin;
+    if (kmax === c1) {
+      h = (c2 - c3) / delta;
+    } else if (kmax === c2) {
+      h = 2 + (c3 - c1) / delta;
+    } else {
+      h = 4 + (c1 - c2) / delta;
+    }
+    h = h * 60;
+    if (h < 0) {
+      h += 360;
+    }
+  }
+  return {
+    type: "hsl",
+    h,
+    s: s * 100,
+    l: l * 100,
+    alpha: rgb.alpha
+  };
+}
+function fromFunction(value) {
+  if (value.slice(-1) !== ")") {
+    return null;
+  }
+  const parts = value.slice(0, value.length - 1).split("(");
+  if (parts.length !== 2) {
+    return null;
+  }
+  const func = parts[0].trim();
+  const content = parts[1].trim();
+  let values;
+  let alphaStr;
+  switch (func) {
+    case "lch":
+    case "lab": {
+      const parts2 = content.split("/");
+      switch (parts2.length) {
+        case 2:
+          alphaStr = parts2[1].trim();
+          break;
+        case 1:
+          break;
+        default:
+          return null;
+      }
+      values = parts2[0].trim().split(/[\s,]+/);
+      break;
+    }
+    case "rgb":
+    case "rgba":
+    case "hsl":
+    case "hsla": {
+      values = content.trim().split(/[\s,]+/);
+      if (values.length === 4) {
+        alphaStr = values.pop().trim();
+      }
+      break;
+    }
+    default: {
+      return {
+        type: "function",
+        func,
+        value: content
+      };
+    }
+  }
+  let alpha = 1;
+  if (typeof alphaStr === "string") {
+    alpha = parseFloat(alphaStr);
+    const index = alphaStr.indexOf("%");
+    const hasPercentage = index !== -1;
+    if (isNaN(alpha) || hasPercentage && index !== alphaStr.length - 1) {
+      return null;
+    }
+    if (hasPercentage) {
+      alpha /= 100;
+    }
+  }
+  if (alpha < 0 || alpha > 1 || values.length !== 3) {
+    return null;
+  }
+  if (alpha === 0) {
+    return {
+      type: "transparent"
+    };
+  }
+  const isPercentage = [];
+  const numbers = [];
+  for (let i = 0; i < 3; i++) {
+    const colorStr = values[i];
+    const index = colorStr.indexOf("%");
+    const hasPercentage = index !== -1;
+    if (hasPercentage && index !== colorStr.length - 1) {
+      return null;
+    }
+    const colorNum = parseFloat(colorStr);
+    if (isNaN(colorNum)) {
+      return null;
+    }
+    isPercentage.push(hasPercentage);
+    numbers.push(colorNum);
+  }
+  switch (func) {
+    case "rgb":
+    case "rgba": {
+      const hasPercengage = isPercentage[0];
+      if (hasPercengage !== isPercentage[1] || hasPercengage !== isPercentage[2]) {
+        return null;
+      }
+      let r = numbers[0];
+      let g = numbers[1];
+      let b = numbers[2];
+      if (hasPercengage) {
+        r = r * 255 / 100;
+        g = g * 255 / 100;
+        b = b * 255 / 100;
+      }
+      return {
+        type: "rgb",
+        r,
+        g,
+        b,
+        alpha
+      };
+    }
+    case "hsl":
+    case "hsla": {
+      if (isPercentage[0] || !isPercentage[1] || !isPercentage[2]) {
+        return null;
+      }
+      return {
+        type: "hsl",
+        h: numbers[0],
+        s: numbers[1],
+        l: numbers[2],
+        alpha
+      };
+    }
+    case "lab":
+    case "lch": {
+      if (!isPercentage[0] || isPercentage[1] || isPercentage[2]) {
+        return null;
+      }
+      return func === "lab" ? {
+        type: "lab",
+        l: numbers[0],
+        a: numbers[1],
+        b: numbers[2],
+        alpha
+      } : {
+        type: "lch",
+        l: numbers[0],
+        c: numbers[1],
+        h: numbers[2],
+        alpha
+      };
+    }
+  }
+  return null;
+}
+function fromHex(value) {
+  if (value.slice(0, 1) === "#") {
+    value = value.slice(1);
+  }
+  if (!/^[\da-f]+$/i.test(value)) {
+    return null;
+  }
+  let alpha = 1;
+  const hex = ["", "", ""];
+  switch (value.length) {
+    case 4: {
+      alpha = parseInt(value[3] + value[3], 16) / 255;
+    }
+    case 3: {
+      hex[0] = value[0] + value[0];
+      hex[1] = value[1] + value[1];
+      hex[2] = value[2] + value[2];
+      break;
+    }
+    case 8: {
+      alpha = parseInt(value[6] + value[7], 16) / 255;
+    }
+    case 6: {
+      hex[0] = value[0] + value[1];
+      hex[1] = value[2] + value[3];
+      hex[2] = value[4] + value[5];
+      break;
+    }
+    default:
+      return null;
+  }
+  return alpha === 0 ? {
+    type: "transparent"
+  } : {
+    type: "rgb",
+    r: parseInt(hex[0], 16),
+    g: parseInt(hex[1], 16),
+    b: parseInt(hex[2], 16),
+    alpha
+  };
+}
+function stringToColor(value) {
+  value = value.toLowerCase().trim();
+  if (colorKeywords[value]) {
+    return { ...colorKeywords[value] };
+  }
+  if (value.indexOf("(") !== -1) {
+    return fromFunction(value);
+  }
+  return fromHex(value);
+}
+function compareColors(color1, color2) {
+  if (color1.type === color2.type) {
+    let testKeys = new Set(Object.keys(color1));
+    switch (color1.type) {
+      case "hsl": {
+        if (color1.s === 0) {
+          testKeys.delete("h");
+        }
+        if (color1.l === 0 || color1.l === 100) {
+          testKeys.delete("h");
+          testKeys.delete("s");
+        }
+      }
+      case "rgb":
+        if (color1.alpha === 0) {
+          testKeys = /* @__PURE__ */ new Set(["a"]);
+        }
+    }
+    const keys = Array.from(testKeys);
+    for (let i = 0; i < keys.length; i++) {
+      const key = keys[i];
+      if (color1[key] !== color2[key]) {
+        return false;
+      }
+    }
+    return true;
+  }
+  const list = [color1, color2].sort((a, b) => a.type.localeCompare(b.type));
+  const item1 = list[0];
+  const item2 = list[1];
+  switch (item1.type) {
+    case "hsl": {
+      switch (item2.type) {
+        case "rgb": {
+          return compareColors(item1, rgb2hsl(item2));
+        }
+        case "transparent":
+          return item1.alpha === 0;
+      }
+      return false;
+    }
+    case "rgb": {
+      switch (item2.type) {
+        case "transparent":
+          return item1.alpha === 0;
+      }
+    }
+  }
+  return false;
+}
+function colorToHexString(color, canCompact = true) {
+  if (color.alpha !== 1) {
+    return null;
+  }
+  let result = "";
+  const attrs = ["r", "g", "b"];
+  for (let i = 0; i < attrs.length; i++) {
+    const value = color[attrs[i]];
+    if (Math.round(value) !== value) {
+      return null;
+    }
+    const hex = value.toString(16);
+    result += (value < 16 ? "0" : "") + hex;
+  }
+  if (result.length !== 6) {
+    return null;
+  }
+  if (canCompact && result[0] === result[1] && result[2] === result[3] && result[4] === result[5]) {
+    result = result[0] + result[2] + result[4];
+  }
+  return "#" + result;
+}
+function colorToString(color) {
+  if (color.alpha === 0) {
+    return "transparent";
+  }
+  switch (color.type) {
+    case "none":
+    case "transparent":
+      return color.type;
+    case "current":
+      return "currentColor";
+    case "rgb": {
+      const hex = colorToHexString(color);
+      if (hex !== null) {
+        return hex;
+      }
+      const list = [color.r, color.g, color.b];
+      if (color.alpha !== 1) {
+        list.push(color.alpha);
+      }
+      return "rgb" + (list.length === 4 ? "a(" : "(") + list.join(", ") + ")";
+    }
+    case "hsl": {
+      const list = [
+        color.h,
+        color.s.toString() + "%",
+        color.l.toString() + "%"
+      ];
+      if (color.alpha !== 1) {
+        list.push(color.alpha);
+      }
+      return "hsl" + (list.length === 4 ? "a(" : "(") + list.join(", ") + ")";
+    }
+    case "lab": {
+      const list = [color.l.toString() + "%", color.a, color.b];
+      if (color.alpha !== 1) {
+        list.push("/ " + color.alpha.toString());
+      }
+      return "lab(" + list.join(" ") + ")";
+    }
+    case "lch": {
+      const list = [color.l.toString() + "%", color.c, color.h];
+      if (color.alpha !== 1) {
+        list.push("/ " + color.alpha.toString());
+      }
+      return "lch(" + list.join(" ") + ")";
+    }
+    case "function": {
+      return color.func + "(" + color.value + ")";
+    }
+  }
+}
+
+export { colorToHexString, colorToString, compareColors, stringToColor };

package/.output/server/node_modules/@iconify/utils/lib/colors/keywords.mjs

@@ -0,0 +1,188 @@
+const colorKeywords = {
+  transparent: {
+    type: "transparent"
+  },
+  none: {
+    type: "none"
+  },
+  currentcolor: {
+    type: "current"
+  }
+};
+function add(keyword, colors) {
+  const type = "rgb";
+  const r = colors[0];
+  const length = colors.length;
+  colorKeywords[keyword] = {
+    type,
+    r,
+    g: length > 1 ? colors[1] : r,
+    b: length > 2 ? colors[2] : r,
+    alpha: length > 3 ? colors[3] : 1
+  };
+}
+add("silver", [192]);
+add("gray", [128]);
+add("white", [255]);
+add("maroon", [128, 0, 0]);
+add("red", [255, 0, 0]);
+add("purple", [128, 0]);
+add("fuchsia", [255, 0]);
+add("green", [0, 128]);
+add("lime", [0, 255]);
+add("olive", [128, 128, 0]);
+add("yellow", [255, 255, 0]);
+add("navy", [0, 0, 128]);
+add("blue", [0, 0, 255]);
+add("teal", [0, 128, 128]);
+add("aqua", [0, 255, 255]);
+add("aliceblue", [240, 248, 255]);
+add("antiquewhite", [250, 235, 215]);
+add("aqua", [0, 255, 255]);
+add("aquamarine", [127, 255, 212]);
+add("azure", [240, 255, 255]);
+add("beige", [245, 245, 220]);
+add("bisque", [255, 228, 196]);
+add("black", [0]);
+add("blanchedalmond", [255, 235, 205]);
+add("blue", [0, 0, 255]);
+add("blueviolet", [138, 43, 226]);
+add("brown", [165, 42, 42]);
+add("burlywood", [222, 184, 135]);
+add("cadetblue", [95, 158, 160]);
+add("chartreuse", [127, 255, 0]);
+add("chocolate", [210, 105, 30]);
+add("coral", [255, 127, 80]);
+add("cornflowerblue", [100, 149, 237]);
+add("cornsilk", [255, 248, 220]);
+add("crimson", [220, 20, 60]);
+add("cyan", [0, 255, 255]);
+add("darkblue", [0, 0, 139]);
+add("darkcyan", [0, 139, 139]);
+add("darkgoldenrod", [184, 134, 11]);
+add("darkgray", [169]);
+add("darkgreen", [0, 100]);
+add("darkgrey", [169]);
+add("darkkhaki", [189, 183, 107]);
+add("darkmagenta", [139, 0]);
+add("darkolivegreen", [85, 107, 47]);
+add("darkorange", [255, 140, 0]);
+add("darkorchid", [153, 50, 204]);
+add("darkred", [139, 0, 0]);
+add("darksalmon", [233, 150, 122]);
+add("darkseagreen", [143, 188]);
+add("darkslateblue", [72, 61, 139]);
+add("darkslategray", [47, 79, 79]);
+add("darkslategrey", [47, 79, 79]);
+add("darkturquoise", [0, 206, 209]);
+add("darkviolet", [148, 0, 211]);
+add("deeppink", [255, 20, 147]);
+add("deepskyblue", [0, 191, 255]);
+add("dimgray", [105]);
+add("dimgrey", [105]);
+add("dodgerblue", [30, 144, 255]);
+add("firebrick", [178, 34, 34]);
+add("floralwhite", [255, 250, 240]);
+add("forestgreen", [34, 139]);
+add("fuchsia", [255, 0]);
+add("gainsboro", [220]);
+add("ghostwhite", [248, 248, 255]);
+add("gold", [255, 215, 0]);
+add("goldenrod", [218, 165, 32]);
+add("gray", [128]);
+add("green", [0, 128]);
+add("greenyellow", [173, 255, 47]);
+add("grey", [128]);
+add("honeydew", [240, 255]);
+add("hotpink", [255, 105, 180]);
+add("indianred", [205, 92, 92]);
+add("indigo", [75, 0, 130]);
+add("ivory", [255, 255, 240]);
+add("khaki", [240, 230, 140]);
+add("lavender", [230, 230, 250]);
+add("lavenderblush", [255, 240, 245]);
+add("lawngreen", [124, 252, 0]);
+add("lemonchiffon", [255, 250, 205]);
+add("lightblue", [173, 216, 230]);
+add("lightcoral", [240, 128, 128]);
+add("lightcyan", [224, 255, 255]);
+add("lightgoldenrodyellow", [250, 250, 210]);
+add("lightgray", [211]);
+add("lightgreen", [144, 238]);
+add("lightgrey", [211]);
+add("lightpink", [255, 182, 193]);
+add("lightsalmon", [255, 160, 122]);
+add("lightseagreen", [32, 178, 170]);
+add("lightskyblue", [135, 206, 250]);
+add("lightslategray", [119, 136, 153]);
+add("lightslategrey", [119, 136, 153]);
+add("lightsteelblue", [176, 196, 222]);
+add("lightyellow", [255, 255, 224]);
+add("lime", [0, 255]);
+add("limegreen", [50, 205]);
+add("linen", [250, 240, 230]);
+add("magenta", [255, 0]);
+add("maroon", [128, 0, 0]);
+add("mediumaquamarine", [102, 205, 170]);
+add("mediumblue", [0, 0, 205]);
+add("mediumorchid", [186, 85, 211]);
+add("mediumpurple", [147, 112, 219]);
+add("mediumseagreen", [60, 179, 113]);
+add("mediumslateblue", [123, 104, 238]);
+add("mediumspringgreen", [0, 250, 154]);
+add("mediumturquoise", [72, 209, 204]);
+add("mediumvioletred", [199, 21, 133]);
+add("midnightblue", [25, 25, 112]);
+add("mintcream", [245, 255, 250]);
+add("mistyrose", [255, 228, 225]);
+add("moccasin", [255, 228, 181]);
+add("navajowhite", [255, 222, 173]);
+add("navy", [0, 0, 128]);
+add("oldlace", [253, 245, 230]);
+add("olive", [128, 128, 0]);
+add("olivedrab", [107, 142, 35]);
+add("orange", [255, 165, 0]);
+add("orangered", [255, 69, 0]);
+add("orchid", [218, 112, 214]);
+add("palegoldenrod", [238, 232, 170]);
+add("palegreen", [152, 251]);
+add("paleturquoise", [175, 238, 238]);
+add("palevioletred", [219, 112, 147]);
+add("papayawhip", [255, 239, 213]);
+add("peachpuff", [255, 218, 185]);
+add("peru", [205, 133, 63]);
+add("pink", [255, 192, 203]);
+add("plum", [221, 160]);
+add("powderblue", [176, 224, 230]);
+add("purple", [128, 0]);
+add("rebeccapurple", [102, 51, 153]);
+add("red", [255, 0, 0]);
+add("rosybrown", [188, 143, 143]);
+add("royalblue", [65, 105, 225]);
+add("saddlebrown", [139, 69, 19]);
+add("salmon", [250, 128, 114]);
+add("sandybrown", [244, 164, 96]);
+add("seagreen", [46, 139, 87]);
+add("seashell", [255, 245, 238]);
+add("sienna", [160, 82, 45]);
+add("silver", [192]);
+add("skyblue", [135, 206, 235]);
+add("slateblue", [106, 90, 205]);
+add("slategray", [112, 128, 144]);
+add("slategrey", [112, 128, 144]);
+add("snow", [255, 250, 250]);
+add("springgreen", [0, 255, 127]);
+add("steelblue", [70, 130, 180]);
+add("tan", [210, 180, 140]);
+add("teal", [0, 128, 128]);
+add("thistle", [216, 191]);
+add("tomato", [255, 99, 71]);
+add("turquoise", [64, 224, 208]);
+add("violet", [238, 130]);
+add("wheat", [245, 222, 179]);
+add("white", [255]);
+add("whitesmoke", [245]);
+add("yellow", [255, 255, 0]);
+add("yellowgreen", [154, 205, 50]);
+
+export { colorKeywords };

package/.output/server/node_modules/@iconify/utils/lib/css/common.mjs

@@ -0,0 +1,90 @@
+import { iconToHTML } from '../svg/html.mjs';
+import { calculateSize } from '../svg/size.mjs';
+import { svgToURL } from '../svg/url.mjs';
+import { makeViewBoxSquare } from '../icon/square.mjs';
+import { iconToSVG } from '../svg/build.mjs';
+import '../icon/defaults.mjs';
+import '../customisations/defaults.mjs';
+import '../svg/defs.mjs';
+
+function getCommonCSSRules(options) {
+  const result = {
+    display: "inline-block",
+    width: "1em",
+    height: "1em"
+  };
+  const varName = options.varName;
+  if (options.pseudoSelector) {
+    result["content"] = "''";
+  }
+  switch (options.mode) {
+    case "background":
+      if (varName) {
+        result["background-image"] = "var(--" + varName + ")";
+      }
+      result["background-repeat"] = "no-repeat";
+      result["background-size"] = "100% 100%";
+      break;
+    case "mask":
+      result["background-color"] = "currentColor";
+      if (varName) {
+        result["mask-image"] = result["-webkit-mask-image"] = "var(--" + varName + ")";
+      }
+      result["mask-repeat"] = result["-webkit-mask-repeat"] = "no-repeat";
+      result["mask-size"] = result["-webkit-mask-size"] = "100% 100%";
+      break;
+  }
+  return result;
+}
+function generateItemCSSRules(icon, options) {
+  const result = {};
+  const varName = options.varName;
+  const buildResult = iconToSVG(icon);
+  let viewBox = buildResult.viewBox;
+  if (viewBox[2] !== viewBox[3]) {
+    if (options.forceSquare) {
+      viewBox = makeViewBoxSquare(viewBox);
+    } else {
+      result["width"] = calculateSize("1em", viewBox[2] / viewBox[3]);
+    }
+  }
+  const svg = iconToHTML(
+    buildResult.body.replace(/currentColor/g, options.color || "black"),
+    {
+      viewBox: `${viewBox[0]} ${viewBox[1]} ${viewBox[2]} ${viewBox[3]}`,
+      width: `${viewBox[2]}`,
+      height: `${viewBox[3]}`
+    }
+  );
+  const url = svgToURL(svg);
+  if (varName) {
+    result["--" + varName] = url;
+  } else {
+    switch (options.mode) {
+      case "background":
+        result["background-image"] = url;
+        break;
+      case "mask":
+        result["mask-image"] = result["-webkit-mask-image"] = url;
+        break;
+    }
+  }
+  return result;
+}
+function generateItemContent(icon, options) {
+  const buildResult = iconToSVG(icon);
+  const viewBox = buildResult.viewBox;
+  const height = options.height;
+  const width = options.width ?? calculateSize(height, viewBox[2] / viewBox[3]);
+  const svg = iconToHTML(
+    buildResult.body.replace(/currentColor/g, options.color || "black"),
+    {
+      viewBox: `${viewBox[0]} ${viewBox[1]} ${viewBox[2]} ${viewBox[3]}`,
+      width: width.toString(),
+      height: height.toString()
+    }
+  );
+  return svgToURL(svg);
+}
+
+export { generateItemCSSRules, generateItemContent, getCommonCSSRules };