@boba-cli/chapstick 0.1.0-alpha.2

package/dist/index.cjs

@@ -0,0 +1,719 @@
+'use strict';
+
+var stringWidth2 = require('string-width');
+var machine = require('@boba-cli/machine');
+
+function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
+
+var stringWidth2__default = /*#__PURE__*/_interopDefault(stringWidth2);
+
+var __require = /* @__PURE__ */ ((x) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x, {
+  get: (a, b) => (typeof require !== "undefined" ? require : a)[b]
+}) : x)(function(x) {
+  if (typeof require !== "undefined") return require.apply(this, arguments);
+  throw Error('Dynamic require of "' + x + '" is not supported');
+});
+
+// src/borders.ts
+var borderStyles = {
+  normal: {
+    top: "\u2500",
+    bottom: "\u2500",
+    left: "\u2502",
+    right: "\u2502",
+    topLeft: "\u250C",
+    topRight: "\u2510",
+    bottomLeft: "\u2514",
+    bottomRight: "\u2518"
+  },
+  rounded: {
+    top: "\u2500",
+    bottom: "\u2500",
+    left: "\u2502",
+    right: "\u2502",
+    topLeft: "\u256D",
+    topRight: "\u256E",
+    bottomLeft: "\u2570",
+    bottomRight: "\u256F"
+  },
+  bold: {
+    top: "\u2501",
+    bottom: "\u2501",
+    left: "\u2503",
+    right: "\u2503",
+    topLeft: "\u250F",
+    topRight: "\u2513",
+    bottomLeft: "\u2517",
+    bottomRight: "\u251B"
+  },
+  double: {
+    top: "\u2550",
+    bottom: "\u2550",
+    left: "\u2551",
+    right: "\u2551",
+    topLeft: "\u2554",
+    topRight: "\u2557",
+    bottomLeft: "\u255A",
+    bottomRight: "\u255D"
+  }
+};
+var defaultBorderStyle = borderStyles.normal;
+
+// src/colors.ts
+function getColorSupport(env) {
+  return env.getColorSupport();
+}
+function getTerminalBackground(env) {
+  return env.getTerminalBackground();
+}
+function isDarkTerminal(env) {
+  const bg = getTerminalBackground(env);
+  return bg !== "light";
+}
+function resolveColor(input, env) {
+  if (!input) {
+    return void 0;
+  }
+  if (typeof input === "string") {
+    return input;
+  }
+  const preferDark = isDarkTerminal(env);
+  return preferDark ? input.dark ?? input.light : input.light ?? input.dark;
+}
+var reflowTruncate;
+var reflowWordwrap;
+try {
+  const reflowjs = __require("terminal-reflowjs");
+  if (typeof reflowjs.truncate === "function") {
+    reflowTruncate = reflowjs.truncate;
+  }
+  if (typeof reflowjs.wordwrap === "function") {
+    reflowWordwrap = reflowjs.wordwrap;
+  }
+} catch {
+}
+function width(text) {
+  return stringWidth2__default.default(String(text ?? ""));
+}
+function truncateLine(line, maxWidth) {
+  if (width(line) <= maxWidth) {
+    return line;
+  }
+  let acc = "";
+  let inAnsi = false;
+  for (const ch of line) {
+    if (ch === "\x1B") {
+      inAnsi = true;
+      acc += ch;
+      continue;
+    }
+    if (inAnsi) {
+      acc += ch;
+      if (/[a-zA-Z]/.test(ch)) {
+        inAnsi = false;
+      }
+      continue;
+    }
+    const nextWidth = width(acc + ch);
+    if (nextWidth > maxWidth) {
+      break;
+    }
+    acc += ch;
+  }
+  return acc;
+}
+function clampWidth(text, maxWidth) {
+  if (!maxWidth || maxWidth < 1) {
+    return text;
+  }
+  if (reflowTruncate) {
+    return text.split("\n").map((line) => reflowTruncate(line, maxWidth)).join("\n");
+  }
+  return text.split("\n").map((line) => truncateLine(line, maxWidth)).join("\n");
+}
+function simpleWordwrap(text, maxWidth) {
+  const lines = text.split("\n");
+  const result = [];
+  for (const line of lines) {
+    if (width(line) <= maxWidth) {
+      result.push(line);
+      continue;
+    }
+    const words = line.split(/(\s+)/);
+    let currentLine = "";
+    for (const word of words) {
+      if (!word) continue;
+      const testLine = currentLine + word;
+      if (width(testLine) <= maxWidth) {
+        currentLine = testLine;
+      } else {
+        if (currentLine.trim()) {
+          result.push(currentLine.trimEnd());
+        }
+        if (width(word.trim()) > maxWidth) {
+          let remaining = word.trim();
+          while (width(remaining) > maxWidth) {
+            const truncated = truncateLine(remaining, maxWidth);
+            result.push(truncated);
+            remaining = remaining.slice(truncated.length);
+          }
+          currentLine = remaining;
+        } else {
+          currentLine = word.trimStart();
+        }
+      }
+    }
+    if (currentLine.trim()) {
+      result.push(currentLine.trimEnd());
+    }
+  }
+  return result.join("\n");
+}
+function wrapWidth(text, maxWidth) {
+  if (!maxWidth || maxWidth < 1) {
+    return text;
+  }
+  if (reflowWordwrap) {
+    return reflowWordwrap(text, maxWidth);
+  }
+  return simpleWordwrap(text, maxWidth);
+}
+function padLines(text, left = 0, right = 0) {
+  if (left === 0 && right === 0) {
+    return text;
+  }
+  const padLeft = " ".repeat(Math.max(0, left));
+  const padRight = " ".repeat(Math.max(0, right));
+  return text.split("\n").map((line) => `${padLeft}${line}${padRight}`).join("\n");
+}
+var defaultContext;
+function createDefaultContext() {
+  if (!defaultContext) {
+    const noColors = { level: 0, hasBasic: false, has256: false, has16m: false };
+    const noopEnv = {
+      get: () => void 0,
+      getColorSupport: () => noColors,
+      getTerminalBackground: () => "unknown"
+    };
+    defaultContext = {
+      env: noopEnv,
+      styleFn: machine.createStyle(noColors)
+    };
+  }
+  return defaultContext;
+}
+function setDefaultContext(context) {
+  defaultContext = context;
+}
+var Style = class _Style {
+  options;
+  /** Track which properties have been explicitly set */
+  setKeys;
+  /** Optional context for rendering - if not set, rendering will throw */
+  context;
+  constructor(options = {}, setKeys, context) {
+    this.options = { ...options };
+    this.setKeys = setKeys ? new Set(setKeys) : new Set(Object.keys(options));
+    this.context = context;
+  }
+  /**
+   * Create a deep copy of this style.
+   */
+  copy() {
+    return new _Style(structuredClone(this.options), new Set(this.setKeys), this.context);
+  }
+  /**
+   * Create a copy of this style with a new context.
+   * @param context - The new context to use for rendering
+   */
+  withContext(context) {
+    return new _Style(this.options, this.setKeys, context);
+  }
+  /**
+   * Inherit unset properties from another style.
+   * Only copies properties that are set in `other` but not set in `this`.
+   * Margins and padding are NOT inherited (matching Go Lip Gloss behavior).
+   */
+  inherit(other) {
+    const newOptions = { ...this.options };
+    const newSetKeys = new Set(this.setKeys);
+    const noInherit = ["padding", "margin"];
+    for (const key of other.setKeys) {
+      if (noInherit.includes(key)) continue;
+      if (!this.setKeys.has(key)) {
+        newOptions[key] = structuredClone(
+          other.options[key]
+        );
+        newSetKeys.add(key);
+      }
+    }
+    return new _Style(newOptions, newSetKeys, this.context);
+  }
+  /**
+   * Check if a property has been explicitly set.
+   */
+  isSet(key) {
+    return this.setKeys.has(key);
+  }
+  /**
+   * Unset a property, reverting to default behavior.
+   */
+  unset(...keys) {
+    const newOptions = { ...this.options };
+    const newSetKeys = new Set(this.setKeys);
+    for (const key of keys) {
+      delete newOptions[key];
+      newSetKeys.delete(key);
+    }
+    return new _Style(newOptions, newSetKeys, this.context);
+  }
+  foreground(color) {
+    return this.with({ foreground: color });
+  }
+  background(color) {
+    return this.with({ background: color });
+  }
+  bold(value = true) {
+    return this.with({ bold: value });
+  }
+  italic(value = true) {
+    return this.with({ italic: value });
+  }
+  underline(value = true) {
+    return this.with({ underline: value });
+  }
+  strikethrough(value = true) {
+    return this.with({ strikethrough: value });
+  }
+  padding(input, right, bottom, left) {
+    const next = normalizeSpacing(input, right, bottom, left);
+    return this.with({ padding: { ...this.options.padding, ...next } });
+  }
+  margin(input, right, bottom, left) {
+    const next = normalizeSpacing(input, right, bottom, left);
+    return this.with({ margin: { ...this.options.margin, ...next } });
+  }
+  width(value) {
+    return this.with({ width: value });
+  }
+  height(value) {
+    return this.with({ height: value });
+  }
+  maxWidth(value) {
+    return this.with({ maxWidth: value });
+  }
+  maxHeight(value) {
+    return this.with({ maxHeight: value });
+  }
+  border(arg = true) {
+    if (typeof arg === "boolean") {
+      if (arg) {
+        return this.with({
+          borderStyle: this.options.borderStyle ?? defaultBorderStyle
+        });
+      } else {
+        return this.unset("borderStyle", "borderColor");
+      }
+    }
+    return this.with({ borderStyle: arg });
+  }
+  /**
+   * Set the border style characters.
+   */
+  borderStyle(style) {
+    return this.with({ borderStyle: style });
+  }
+  /**
+   * Set the border foreground color.
+   */
+  borderForeground(color) {
+    return this.with({ borderColor: color });
+  }
+  /**
+   * Set horizontal alignment.
+   * @deprecated Use alignHorizontal() instead.
+   */
+  align(value) {
+    return this.alignHorizontal(value);
+  }
+  /**
+   * Set horizontal alignment (left, center, right).
+   */
+  alignHorizontal(value) {
+    return this.with({ alignHorizontal: value });
+  }
+  /**
+   * Set vertical alignment (top, center, bottom).
+   * Only applies when height is set.
+   */
+  alignVertical(value) {
+    return this.with({ alignVertical: value });
+  }
+  /**
+   * Enable inline mode. When true:
+   * - Newlines are stripped from the input
+   * - Padding and margins are not applied
+   */
+  inline(value = true) {
+    return this.with({ inline: value });
+  }
+  /**
+   * Render the style to a string.
+   * Uses the default no-op context if none was provided.
+   */
+  render(text) {
+    const ctx = this.context ?? createDefaultContext();
+    return this.renderWithContext(text, ctx);
+  }
+  /**
+   * Render the style to a string with an explicit context.
+   * @param text - Text to render
+   * @param ctx - Context for rendering
+   */
+  renderWithContext(text, ctx) {
+    const opts = this.options;
+    const isInline = opts.inline ?? false;
+    let content = text ?? "";
+    if (isInline) {
+      content = content.replace(/\r?\n/g, "");
+    }
+    const targetWidth = opts.width ?? opts.maxWidth;
+    const hasBorder = opts.borderStyle !== void 0 || this.setKeys.has("borderColor");
+    const padding = isInline ? { top: 0, right: 0, bottom: 0, left: 0 } : normalizeSpacing(opts.padding ?? 0);
+    const borderWidth = hasBorder ? 2 : 0;
+    const innerTargetWidth = targetWidth !== void 0 ? Math.max(0, targetWidth - padding.left - padding.right - borderWidth) : void 0;
+    if (opts.maxWidth && innerTargetWidth !== void 0) {
+      content = wrapWidth(content, innerTargetWidth);
+    }
+    if (opts.width && opts.width > 0 && innerTargetWidth !== void 0) {
+      content = clampWidth(content, innerTargetWidth);
+    }
+    const lines = content.split("\n");
+    const aligned = alignLinesHorizontal(
+      lines,
+      opts.alignHorizontal,
+      innerTargetWidth
+    );
+    const padded = isInline ? aligned : applySpacing(aligned, padding);
+    const borderStyle = opts.borderStyle ?? defaultBorderStyle;
+    const bordered = hasBorder ? applyBorder(padded, borderStyle, opts.borderColor, ctx) : padded;
+    const sized = applyHeight(
+      bordered,
+      opts.height,
+      opts.maxHeight,
+      opts.alignVertical
+    );
+    const colored = applyTextStyle(sized, opts, ctx);
+    if (isInline) {
+      return colored.join("");
+    }
+    const withMargin = applySpacing(
+      colored,
+      normalizeSpacing(opts.margin ?? 0)
+    ).join("\n");
+    return withMargin;
+  }
+  with(patch) {
+    const newSetKeys = new Set(this.setKeys);
+    for (const key of Object.keys(patch)) {
+      newSetKeys.add(key);
+    }
+    return new _Style({ ...this.options, ...patch }, newSetKeys, this.context);
+  }
+};
+function normalizeSpacing(input, right, bottom, left) {
+  if (typeof input === "number") {
+    const v = input;
+    if (right === void 0 && bottom === void 0 && left === void 0) {
+      return { top: v, right: v, bottom: v, left: v };
+    }
+    if (right !== void 0 && bottom === void 0 && left === void 0) {
+      return { top: v, right, bottom: v, left: right };
+    }
+    return {
+      top: v,
+      right: right ?? 0,
+      bottom: bottom ?? 0,
+      left: left ?? 0
+    };
+  }
+  return {
+    top: input.top ?? 0,
+    right: input.right ?? 0,
+    bottom: input.bottom ?? 0,
+    left: input.left ?? 0
+  };
+}
+function alignLinesHorizontal(lines, align, targetWidth) {
+  if (!targetWidth && !align) {
+    return lines;
+  }
+  const maxLineWidth = lines.reduce(
+    (acc, line) => Math.max(acc, width(line)),
+    0
+  );
+  const width2 = targetWidth ?? maxLineWidth;
+  const effectiveAlign = align ?? "left";
+  return lines.map((line) => {
+    const w = width(line);
+    const space = Math.max(0, width2 - w);
+    switch (effectiveAlign) {
+      case "center": {
+        const left = Math.floor(space / 2);
+        const right = space - left;
+        return `${" ".repeat(left)}${line}${" ".repeat(right)}`;
+      }
+      case "right":
+        return `${" ".repeat(space)}${line}`;
+      case "left":
+      default:
+        return `${line}${" ".repeat(space)}`;
+    }
+  });
+}
+function applySpacing(lines, spacing) {
+  const { top, right, bottom, left } = spacing;
+  const spaceLeft = " ".repeat(Math.max(0, left));
+  const spaceRight = " ".repeat(Math.max(0, right));
+  const spaced = lines.map((line) => `${spaceLeft}${line}${spaceRight}`);
+  const maxWidth = spaced.reduce(
+    (acc, line) => Math.max(acc, width(line)),
+    0
+  );
+  const empty = " ".repeat(maxWidth);
+  const withTop = Array.from({ length: Math.max(0, top) }, () => empty).concat(
+    spaced
+  );
+  return withTop.concat(
+    Array.from({ length: Math.max(0, bottom) }, () => empty)
+  );
+}
+function applyBorder(lines, style, borderColor, ctx) {
+  if (!style) return lines;
+  const widthMax = lines.reduce(
+    (acc, line) => Math.max(acc, width(line)),
+    0
+  );
+  const top = style.top.repeat(Math.max(0, widthMax));
+  const bottom = style.bottom.repeat(Math.max(0, widthMax));
+  const wrap = (line) => `${style.left}${line}${style.right}`;
+  const sidePadded = lines.map((line) => {
+    const pad = Math.max(0, widthMax - width(line));
+    return wrap(`${line}${" ".repeat(pad)}`);
+  });
+  const topLine = `${style.topLeft}${top}${style.topRight}`;
+  const bottomLine = `${style.bottomLeft}${bottom}${style.bottomRight}`;
+  const withBorder = [topLine, ...sidePadded, bottomLine];
+  if (!borderColor) {
+    return withBorder;
+  }
+  const colored = applyColor(withBorder.join("\n"), borderColor, ctx);
+  return colored.split("\n");
+}
+function applyHeight(lines, height, maxHeight, vAlign) {
+  let result = [...lines];
+  if (height !== void 0 && height > 0) {
+    const widthMax = Math.max(...result.map(width), 0);
+    const blank = " ".repeat(widthMax);
+    if (result.length < height) {
+      const missing = height - result.length;
+      const topPad = vAlign === "bottom" ? missing : vAlign === "center" ? Math.floor(missing / 2) : 0;
+      const bottomPad = missing - topPad;
+      const topFill = [];
+      for (let i = 0; i < topPad; i++) topFill.push(blank);
+      const bottomFill = [];
+      for (let i = 0; i < bottomPad; i++) bottomFill.push(blank);
+      result = [...topFill, ...result, ...bottomFill];
+    } else if (result.length > height) {
+      result = result.slice(0, height);
+    }
+  }
+  if (maxHeight !== void 0 && maxHeight > 0 && result.length > maxHeight) {
+    result = result.slice(0, maxHeight);
+  }
+  return result;
+}
+function applyTextStyle(lines, opts, ctx) {
+  const fg = resolveColor(opts.foreground, ctx.env);
+  const bg = resolveColor(opts.background, ctx.env);
+  const styleFn = (input) => {
+    let instance = ctx.styleFn;
+    if (fg) instance = applyForeground(instance, fg);
+    if (bg) instance = applyBackground(instance, bg);
+    if (opts.bold) instance = instance.bold;
+    if (opts.italic) instance = instance.italic;
+    if (opts.underline) instance = instance.underline;
+    if (opts.strikethrough) instance = instance.strikethrough;
+    return instance(input);
+  };
+  return lines.map(styleFn);
+}
+function applyForeground(instance, color) {
+  if (color.startsWith("#")) {
+    return instance.hex(color);
+  }
+  const rgbMatch = color.match(
+    /^rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$/i
+  );
+  if (rgbMatch) {
+    const r = parseInt(rgbMatch[1] ?? "0", 10);
+    const g = parseInt(rgbMatch[2] ?? "0", 10);
+    const b = parseInt(rgbMatch[3] ?? "0", 10);
+    return instance.rgb(r, g, b);
+  }
+  const namedColor = color.toLowerCase();
+  const prop = instance[namedColor];
+  if (typeof prop === "function" || typeof prop === "object" && prop !== null) {
+    return prop;
+  }
+  return instance.hex(color);
+}
+function applyBackground(instance, color) {
+  if (color.startsWith("#")) {
+    return instance.bgHex(color);
+  }
+  const rgbMatch = color.match(
+    /^rgb\s*\(\s*(\d+)\s*,\s*(\d+)\s*,\s*(\d+)\s*\)$/i
+  );
+  if (rgbMatch) {
+    const r = parseInt(rgbMatch[1] ?? "0", 10);
+    const g = parseInt(rgbMatch[2] ?? "0", 10);
+    const b = parseInt(rgbMatch[3] ?? "0", 10);
+    return instance.bgRgb(r, g, b);
+  }
+  const bgColor = `bg${color.charAt(0).toUpperCase()}${color.slice(1).toLowerCase()}`;
+  const prop = instance[bgColor];
+  if (typeof prop === "function" || typeof prop === "object" && prop !== null) {
+    return prop;
+  }
+  return instance.bgHex(color);
+}
+function applyColor(text, color, ctx) {
+  const resolved = resolveColor(color, ctx.env);
+  if (!resolved) return text;
+  return text.split("\n").map((line) => {
+    let instance = ctx.styleFn;
+    instance = applyForeground(instance, resolved);
+    return instance(line);
+  }).join("\n");
+}
+
+// src/provider.ts
+var ChapstickStyleProvider = class {
+  context;
+  /**
+   * Create a new style provider.
+   * @param env - Environment adapter for detecting terminal capabilities
+   * @param styleFn - Style function for applying ANSI styling
+   */
+  constructor(env, styleFn) {
+    this.context = { env, styleFn };
+  }
+  createStyle() {
+    return new Style({}, void 0, this.context);
+  }
+  get semanticStyles() {
+    const ctx = this.context;
+    return {
+      success: new Style({}, void 0, ctx).bold(true).foreground("#50FA7B"),
+      error: new Style({}, void 0, ctx).bold(true).foreground("#FF5555"),
+      warning: new Style({}, void 0, ctx).bold(true).foreground("#F1FA8C"),
+      info: new Style({}, void 0, ctx).foreground("#8BE9FD"),
+      muted: new Style({}, void 0, ctx).foreground("#6272A4"),
+      highlight: new Style({}, void 0, ctx).background("#44475A").foreground("#F8F8F2"),
+      header: new Style({}, void 0, ctx).bold(true).foreground("#00D9FF").padding(0, 1)
+    };
+  }
+};
+function joinHorizontal(first, ...rest) {
+  const spacing = typeof first === "number" ? first : 0;
+  const blocks = typeof first === "number" ? rest : [first, ...rest];
+  if (blocks.length === 0) return "";
+  const split = blocks.map((b) => b.split("\n"));
+  const widths = split.map(
+    (lines) => Math.max(...lines.map((l) => stringWidth2__default.default(l)), 0)
+  );
+  const height = Math.max(...split.map((lines) => lines.length));
+  const padded = split.map((lines, idx) => {
+    const w = widths[idx] ?? 0;
+    const missing = height - lines.length;
+    const filled = lines.concat(Array(missing).fill(""));
+    return filled.map((line) => padToWidth(line, w));
+  });
+  const gap = " ".repeat(Math.max(0, spacing));
+  const rows = [];
+  for (let i = 0; i < height; i++) {
+    rows.push(padded.map((col) => col[i] ?? "").join(gap));
+  }
+  return rows.join("\n");
+}
+function joinVertical(first, ...rest) {
+  const spacing = typeof first === "number" ? first : 0;
+  const blocks = typeof first === "number" ? rest : [first, ...rest];
+  if (blocks.length === 0) return "";
+  const gap = "\n".repeat(Math.max(0, spacing + 1));
+  return blocks.join(gap);
+}
+function place(width2, height, hAlign, vAlign, content) {
+  const lines = content.split("\n");
+  const clamped = lines.slice(0, height).map((line) => truncateLine2(line, width2));
+  const paddedLines = clamped.map((line) => alignLine(line, width2, hAlign));
+  const missing = height - paddedLines.length;
+  const topPad = vAlign === "top" ? 0 : vAlign === "center" ? Math.floor(missing / 2) : missing;
+  const bottomPad = missing - topPad;
+  const empty = " ".repeat(Math.max(0, width2));
+  const prefix = createPadLines(empty, Math.max(0, topPad));
+  const suffix = createPadLines(empty, Math.max(0, bottomPad));
+  return [...prefix, ...paddedLines, ...suffix].join("\n");
+}
+function createPadLines(line, count) {
+  if (count <= 0) return [];
+  return Array(count).fill(line);
+}
+function padToWidth(input, width2) {
+  const w = stringWidth2__default.default(input);
+  if (w >= width2) return input;
+  return `${input}${" ".repeat(width2 - w)}`;
+}
+function truncateLine2(input, maxWidth) {
+  const w = stringWidth2__default.default(input);
+  if (w <= maxWidth) return input;
+  let acc = "";
+  for (const ch of input) {
+    if (stringWidth2__default.default(acc + ch) > maxWidth) break;
+    acc += ch;
+  }
+  return acc;
+}
+function alignLine(input, width2, align) {
+  const w = stringWidth2__default.default(input);
+  const space = Math.max(0, width2 - w);
+  if (align === "right") {
+    return `${" ".repeat(space)}${input}`;
+  }
+  if (align === "center") {
+    const left = Math.floor(space / 2);
+    const right = space - left;
+    return `${" ".repeat(left)}${input}${" ".repeat(right)}`;
+  }
+  return `${input}${" ".repeat(space)}`;
+}
+
+exports.ChapstickStyleProvider = ChapstickStyleProvider;
+exports.Style = Style;
+exports.borderStyles = borderStyles;
+exports.clampWidth = clampWidth;
+exports.createDefaultContext = createDefaultContext;
+exports.defaultBorderStyle = defaultBorderStyle;
+exports.getColorSupport = getColorSupport;
+exports.getTerminalBackground = getTerminalBackground;
+exports.joinHorizontal = joinHorizontal;
+exports.joinVertical = joinVertical;
+exports.padLines = padLines;
+exports.place = place;
+exports.resolveColor = resolveColor;
+exports.setDefaultContext = setDefaultContext;
+exports.width = width;
+exports.wrapWidth = wrapWidth;
+//# sourceMappingURL=index.cjs.map
+//# sourceMappingURL=index.cjs.map