chess2img 0.3.1 → 0.4.1

package/dist/index.js

@@ -37,23 +37,6 @@ var IOError = class extends Error {
   }
 };
 
-// src/core/parsers.ts
-import { Chess } from "chess.js";
-
-// src/core/board.ts
-var FILES = ["a", "b", "c", "d", "e", "f", "g", "h"];
-var RANKS = ["8", "7", "6", "5", "4", "3", "2", "1"];
-var SQUARES = RANKS.flatMap(
-  (rank) => FILES.map((file) => `${file}${rank}`)
-);
-function createEmptyBoardPosition() {
-  return {
-    squares: Object.fromEntries(
-      SQUARES.map((square) => [square, null])
-    )
-  };
-}
-
 // src/core/validators.ts
 import { createCanvas } from "canvas";
 var SQUARE_PATTERN = /^[a-h][1-8]$/;
@@ -246,71 +229,23 @@ function validateHighlightsInput(highlights, highlightSquares) {
   validateHighlightOptions(highlightSquares);
 }
 
-// src/core/parsers.ts
-var PIECE_SYMBOL_TO_KEY = {
-  K: "wK",
-  Q: "wQ",
-  R: "wR",
-  B: "wB",
-  N: "wN",
-  P: "wP",
-  k: "bK",
-  q: "bQ",
-  r: "bR",
-  b: "bB",
-  n: "bN",
-  p: "bP"
-};
-function chessBoardToBoardArray(board) {
-  return board.map(
-    (rank) => rank.map((piece) => {
-      if (!piece) {
-        return null;
-      }
-      return piece.color === "w" ? piece.type.toUpperCase() : piece.type;
-    })
-  );
-}
-function parseFEN(fen) {
-  const chess = new Chess();
-  try {
-    chess.load(fen);
-  } catch (error) {
-    throw new ParseError("Invalid FEN", { cause: error });
-  }
-  return parseBoardArray(chessBoardToBoardArray(chess.board()));
-}
-function parsePGN(pgn) {
-  const chess = new Chess();
-  try {
-    chess.loadPgn(pgn);
-  } catch (error) {
-    throw new ParseError("Invalid PGN", { cause: error });
-  }
-  return parseBoardArray(chessBoardToBoardArray(chess.board()));
-}
-function parseBoardArray(board) {
-  const validatedBoard = validateBoardArray(board);
-  const position = createEmptyBoardPosition();
-  validatedBoard.forEach((rank, rankIndex) => {
-    rank.forEach((cell, fileIndex) => {
-      if (cell === null) {
-        return;
-      }
-      const pieceKey = PIECE_SYMBOL_TO_KEY[cell];
-      if (!pieceKey) {
-        throw new ValidationError(`Invalid board piece: ${cell}`);
-      }
-      const square = `${FILES[fileIndex]}${8 - rankIndex}`;
-      position.squares[square] = pieceKey;
-    });
-  });
-  return position;
-}
-
 // src/render/canvas-renderer.ts
 import { createCanvas as createCanvas3 } from "canvas";
 
+// src/core/board.ts
+var FILES = ["a", "b", "c", "d", "e", "f", "g", "h"];
+var RANKS = ["8", "7", "6", "5", "4", "3", "2", "1"];
+var SQUARES = RANKS.flatMap(
+  (rank) => FILES.map((file) => `${file}${rank}`)
+);
+function createEmptyBoardPosition() {
+  return {
+    squares: Object.fromEntries(
+      SQUARES.map((square) => [square, null])
+    )
+  };
+}
+
 // src/core/geometry.ts
 function createBoardGeometry({
   size,
@@ -739,6 +674,9 @@ async function drawPieces(context, request, geometry) {
   }
 }
 var CanvasPngRenderer = class {
+  createOutputBuffer(canvas) {
+    return canvas.toBuffer("image/png");
+  }
   async render(request) {
     try {
       const geometry = createBoardGeometry({
@@ -756,7 +694,7 @@ var CanvasPngRenderer = class {
       drawCircleHighlights(context, request, geometry);
       drawCoordinates(context, request, geometry);
       await drawPieces(context, request, geometry);
-      return canvas.toBuffer("image/png");
+      return this.createOutputBuffer(canvas);
     } catch (error) {
       if (error instanceof RenderError) {
         throw error;
@@ -766,6 +704,270 @@ var CanvasPngRenderer = class {
   }
 };
 
+// src/render/canvas-jpeg-renderer.ts
+import "canvas";
+var CanvasJpegRenderer = class extends CanvasPngRenderer {
+  createOutputBuffer(canvas) {
+    return canvas.toBuffer("image/jpeg");
+  }
+};
+
+// src/render/svg-renderer.ts
+import { readFile as readFile2 } from "fs/promises";
+import { createCanvas as createCanvas5 } from "canvas";
+var svgSourceCache2 = new SourceAssetCache();
+var binarySourceCache = new SourceAssetCache();
+var measureContext = createCanvas5(1, 1).getContext("2d");
+var MIN_COORDINATE_FONT_SIZE2 = 8;
+var MAX_FILE_LABEL_WIDTH_RATIO2 = 0.75;
+var MAX_RANK_LABEL_WIDTH_RATIO2 = 0.7;
+var MAX_LABEL_HEIGHT_RATIO2 = 0.7;
+var INSIDE_COORDINATE_MAX_FONT_RATIO2 = 0.34;
+var INSIDE_LIGHT_LABEL_COLOR2 = "rgba(255,255,255,0.6)";
+var INSIDE_DARK_LABEL_COLOR2 = "rgba(0,0,0,0.45)";
+function escapeXml(value) {
+  return value.replaceAll("&", "&amp;").replaceAll("<", "&lt;").replaceAll(">", "&gt;").replaceAll('"', "&quot;").replaceAll("'", "&apos;");
+}
+function isDarkSquare2(square) {
+  const fileIndex = square.charCodeAt(0) - 97;
+  const rankNumber = Number(square[1]);
+  return (fileIndex + rankNumber) % 2 === 1;
+}
+function resolveInsideLabelColor2(request, square) {
+  if (request.coordinates.color) {
+    return request.coordinates.color;
+  }
+  return isDarkSquare2(square) ? INSIDE_LIGHT_LABEL_COLOR2 : INSIDE_DARK_LABEL_COLOR2;
+}
+function resolveHighlightOpacity2(style, color, opacity) {
+  if (opacity !== void 0) {
+    return opacity;
+  }
+  if (style === "circle" || color !== void 0) {
+    return 0.9;
+  }
+  return 1;
+}
+function resolveCircleLineWidth2(squareSize, lineWidth) {
+  const candidate = lineWidth ?? squareSize * 0.08;
+  return Math.max(2, Math.min(8, candidate));
+}
+function resolveCircleRadius2(squareSize, radius, lineWidth) {
+  const radiusPx = squareSize * (radius ?? 0.42);
+  return Math.max(0, radiusPx - lineWidth / 2);
+}
+function resolveBorderCoordinateFontSize2(geometry) {
+  const maxFontSize = Math.floor(
+    Math.min(geometry.squareSize * 0.6, geometry.borderSize * 0.65)
+  );
+  for (let candidate = maxFontSize; candidate >= MIN_COORDINATE_FONT_SIZE2; candidate -= 1) {
+    measureContext.font = `${candidate}px sans-serif`;
+    const filesFit = geometry.borderFileLabels.every((label) => {
+      const metrics = measureContext.measureText(label.text);
+      const textHeight = metrics.actualBoundingBoxAscent + metrics.actualBoundingBoxDescent;
+      return metrics.width <= geometry.squareSize * MAX_FILE_LABEL_WIDTH_RATIO2 && textHeight <= geometry.borderSize * MAX_LABEL_HEIGHT_RATIO2;
+    });
+    const ranksFit = geometry.borderRankLabels.every((label) => {
+      const metrics = measureContext.measureText(label.text);
+      const textHeight = metrics.actualBoundingBoxAscent + metrics.actualBoundingBoxDescent;
+      return metrics.width <= geometry.borderSize * MAX_RANK_LABEL_WIDTH_RATIO2 && textHeight <= geometry.squareSize * MAX_LABEL_HEIGHT_RATIO2;
+    });
+    if (filesFit && ranksFit) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function resolveInsideCoordinateFontSize2(geometry) {
+  const maxFontSize = Math.floor(
+    geometry.squareSize * INSIDE_COORDINATE_MAX_FONT_RATIO2
+  );
+  for (let candidate = maxFontSize; candidate >= MIN_COORDINATE_FONT_SIZE2; candidate -= 1) {
+    measureContext.font = `${candidate}px sans-serif`;
+    const filesFit = geometry.insideFileLabels.every((label) => {
+      const metrics = measureContext.measureText(label.text);
+      const textHeight = metrics.actualBoundingBoxAscent + metrics.actualBoundingBoxDescent;
+      return metrics.width <= geometry.insideLabelMaxWidth && textHeight <= geometry.insideLabelMaxHeight;
+    });
+    const ranksFit = geometry.insideRankLabels.every((label) => {
+      const metrics = measureContext.measureText(label.text);
+      const textHeight = metrics.actualBoundingBoxAscent + metrics.actualBoundingBoxDescent;
+      return metrics.width <= geometry.insideLabelMaxWidth && textHeight <= geometry.insideLabelMaxHeight;
+    });
+    if (filesFit && ranksFit) {
+      return candidate;
+    }
+  }
+  return null;
+}
+function textAnchor(value) {
+  if (value === "center") {
+    return "middle";
+  }
+  return value === "right" ? "end" : "start";
+}
+function dominantBaseline(value) {
+  if (value === "middle") {
+    return "middle";
+  }
+  return value === "bottom" ? "text-after-edge" : "hanging";
+}
+async function readSvgSource2(filePath) {
+  const cached = svgSourceCache2.get(filePath);
+  if (cached) {
+    return cached;
+  }
+  try {
+    const source = await readFile2(filePath, "utf8");
+    svgSourceCache2.set(filePath, source);
+    return source;
+  } catch (error) {
+    throw new RenderError(`Failed to read SVG asset: ${filePath}`, { cause: error });
+  }
+}
+async function readBinarySource(filePath) {
+  const cached = binarySourceCache.get(filePath);
+  if (cached) {
+    return cached;
+  }
+  try {
+    const source = await readFile2(filePath);
+    binarySourceCache.set(filePath, source);
+    return source;
+  } catch (error) {
+    throw new RenderError(`Failed to read image asset: ${filePath}`, { cause: error });
+  }
+}
+function stripSvgPreamble(source) {
+  return source.replace(/^\uFEFF/, "").replace(/<\?xml[\s\S]*?\?>/gi, "").replace(/<!doctype[\s\S]*?>/gi, "").trim();
+}
+function inlineSvgPiece(source, x, y, size) {
+  const sanitized = stripSvgPreamble(source);
+  if (!sanitized.startsWith("<svg")) {
+    throw new RenderError("Invalid SVG asset source");
+  }
+  return sanitized.replace(/<svg\b([^>]*)>/i, (_match, attrs) => {
+    const cleanedAttrs = attrs.replace(/\s(?:x|y|width|height)=(".*?"|'.*?'|[^\s>]+)/gi, "").trim();
+    const preservedAttrs = cleanedAttrs ? ` ${cleanedAttrs}` : "";
+    return `<svg x="${x}" y="${y}" width="${size}" height="${size}"${preservedAttrs}>`;
+  });
+}
+async function renderPieceElement(asset, x, y, size) {
+  if (asset.kind === "svg") {
+    const source = await readSvgSource2(asset.source);
+    return inlineSvgPiece(source, x, y, size);
+  }
+  const buffer = await readBinarySource(asset.source);
+  return [
+    `<image x="${x}" y="${y}" width="${size}" height="${size}"`,
+    ` href="data:image/png;base64,${buffer.toString("base64")}" />`
+  ].join("");
+}
+async function renderPieces(request, geometry) {
+  const pieces = [];
+  for (const square of SQUARES) {
+    const pieceKey = request.board.squares[square];
+    if (!pieceKey) {
+      continue;
+    }
+    const squareGeometry = geometry.squares[square];
+    pieces.push(
+      await renderPieceElement(
+        request.theme.pieces[pieceKey],
+        squareGeometry.x,
+        squareGeometry.y,
+        squareGeometry.size
+      )
+    );
+  }
+  return pieces;
+}
+function renderCoordinates(request, geometry) {
+  if (!request.coordinates.enabled) {
+    return [];
+  }
+  if (request.coordinates.position === "border") {
+    if (geometry.borderSize === 0) {
+      return [];
+    }
+    const fontSize2 = resolveBorderCoordinateFontSize2(geometry);
+    if (fontSize2 === null) {
+      return [];
+    }
+    return [
+      ...geometry.borderFileLabels,
+      ...geometry.borderRankLabels
+    ].map(
+      (label) => `<text x="${label.x}" y="${label.y}" fill="${escapeXml(request.coordinates.color ?? "#333")}" font-family="sans-serif" font-size="${fontSize2}" text-anchor="middle" dominant-baseline="middle">${escapeXml(label.text)}</text>`
+    );
+  }
+  const fontSize = resolveInsideCoordinateFontSize2(geometry);
+  if (fontSize === null) {
+    return [];
+  }
+  return [
+    ...geometry.insideFileLabels.map(
+      (label) => `<text x="${label.x}" y="${label.y}" fill="${escapeXml(resolveInsideLabelColor2(request, label.square))}" font-family="sans-serif" font-size="${fontSize}" text-anchor="${textAnchor(label.textAlign)}" dominant-baseline="${dominantBaseline(label.textBaseline)}">${escapeXml(label.text)}</text>`
+    ),
+    ...geometry.insideRankLabels.map(
+      (label) => `<text x="${label.x}" y="${label.y}" fill="${escapeXml(resolveInsideLabelColor2(request, label.square))}" font-family="sans-serif" font-size="${fontSize}" text-anchor="${textAnchor(label.textAlign)}" dominant-baseline="${dominantBaseline(label.textBaseline)}">${escapeXml(label.text)}</text>`
+    )
+  ];
+}
+var SvgRenderer = class {
+  async render(request) {
+    try {
+      const geometry = createBoardGeometry({
+        size: request.size,
+        padding: request.padding,
+        borderSize: request.borderSize,
+        flipped: request.flipped
+      });
+      const elements = [
+        `<rect x="0" y="0" width="${geometry.imageWidth}" height="${geometry.imageHeight}" fill="${escapeXml(request.colors.lightSquare)}" />`
+      ];
+      for (const square of SQUARES) {
+        const squareGeometry = geometry.squares[square];
+        elements.push(
+          `<rect x="${squareGeometry.x}" y="${squareGeometry.y}" width="${squareGeometry.size}" height="${squareGeometry.size}" fill="${escapeXml(isDarkSquare2(square) ? request.colors.darkSquare : request.colors.lightSquare)}" />`
+        );
+      }
+      for (const highlight of request.highlights) {
+        if (highlight.style !== "fill") {
+          continue;
+        }
+        const squareGeometry = geometry.squares[highlight.square];
+        elements.push(
+          `<rect x="${squareGeometry.x}" y="${squareGeometry.y}" width="${squareGeometry.size}" height="${squareGeometry.size}" fill="${escapeXml(highlight.color ?? request.colors.highlight)}" fill-opacity="${resolveHighlightOpacity2(highlight.style, highlight.color, highlight.opacity)}" />`
+        );
+      }
+      for (const highlight of request.highlights) {
+        if (highlight.style !== "circle") {
+          continue;
+        }
+        const squareGeometry = geometry.squares[highlight.square];
+        const lineWidth = resolveCircleLineWidth2(squareGeometry.size, highlight.lineWidth);
+        const radius = resolveCircleRadius2(squareGeometry.size, highlight.radius, lineWidth);
+        elements.push(
+          `<circle cx="${squareGeometry.x + squareGeometry.size / 2}" cy="${squareGeometry.y + squareGeometry.size / 2}" r="${radius}" fill="none" stroke="${escapeXml(highlight.color ?? "#ffcc00")}" stroke-width="${lineWidth}" stroke-opacity="${resolveHighlightOpacity2(highlight.style, highlight.color, highlight.opacity)}" />`
+        );
+      }
+      elements.push(...renderCoordinates(request, geometry));
+      elements.push(...await renderPieces(request, geometry));
+      return [
+        `<svg xmlns="http://www.w3.org/2000/svg" width="${geometry.imageWidth}" height="${geometry.imageHeight}" viewBox="0 0 ${geometry.imageWidth} ${geometry.imageHeight}">`,
+        ...elements,
+        "</svg>"
+      ].join("");
+    } catch (error) {
+      if (error instanceof RenderError) {
+        throw error;
+      }
+      throw new RenderError("Failed to render chess board as SVG", { cause: error });
+    }
+  }
+};
+
 // src/utils/io.ts
 import { writeFile } from "fs/promises";
 async function writeBufferToFile(filePath, buffer) {
@@ -775,6 +977,13 @@ async function writeBufferToFile(filePath, buffer) {
     throw new IOError(`Failed to write file: ${filePath}`, { cause: error });
   }
 }
+async function writeStringToFile(filePath, contents) {
+  try {
+    await writeFile(filePath, contents, "utf8");
+  } catch (error) {
+    throw new IOError(`Failed to write file: ${filePath}`, { cause: error });
+  }
+}
 
 // src/core/highlights.ts
 function normalizeHighlightEntries(input) {
@@ -1014,6 +1223,112 @@ function normalizeRenderInputs(options) {
   };
 }
 
+// src/core/parsers.ts
+import { Chess } from "chess.js";
+var PIECE_SYMBOL_TO_KEY = {
+  K: "wK",
+  Q: "wQ",
+  R: "wR",
+  B: "wB",
+  N: "wN",
+  P: "wP",
+  k: "bK",
+  q: "bQ",
+  r: "bR",
+  b: "bB",
+  n: "bN",
+  p: "bP"
+};
+function chessBoardToBoardArray(board) {
+  return board.map(
+    (rank) => rank.map((piece) => {
+      if (!piece) {
+        return null;
+      }
+      return piece.color === "w" ? piece.type.toUpperCase() : piece.type;
+    })
+  );
+}
+function parseFEN(fen) {
+  const chess = new Chess();
+  try {
+    chess.load(fen);
+  } catch (error) {
+    throw new ParseError("Invalid FEN", { cause: error });
+  }
+  return parseBoardArray(chessBoardToBoardArray(chess.board()));
+}
+function parsePGN(pgn) {
+  const chess = new Chess();
+  try {
+    chess.loadPgn(pgn);
+  } catch (error) {
+    throw new ParseError("Invalid PGN", { cause: error });
+  }
+  return parseBoardArray(chessBoardToBoardArray(chess.board()));
+}
+function parseBoardArray(board) {
+  const validatedBoard = validateBoardArray(board);
+  const position = createEmptyBoardPosition();
+  validatedBoard.forEach((rank, rankIndex) => {
+    rank.forEach((cell, fileIndex) => {
+      if (cell === null) {
+        return;
+      }
+      const pieceKey = PIECE_SYMBOL_TO_KEY[cell];
+      if (!pieceKey) {
+        throw new ValidationError(`Invalid board piece: ${cell}`);
+      }
+      const square = `${FILES[fileIndex]}${8 - rankIndex}`;
+      position.squares[square] = pieceKey;
+    });
+  });
+  return position;
+}
+
+// src/api/render-request.ts
+function parseInputPosition(options) {
+  if (typeof options.fen === "string") {
+    return parseFEN(options.fen);
+  }
+  if (typeof options.pgn === "string") {
+    return parsePGN(options.pgn);
+  }
+  if (Array.isArray(options.board)) {
+    return parseBoardArray(options.board);
+  }
+  throw new ValidationError("Exactly one of fen, pgn, or board must be provided");
+}
+function validateSingleInputSource(options) {
+  const provided = [
+    typeof options.fen === "string" ? options.fen : void 0,
+    typeof options.pgn === "string" ? options.pgn : void 0,
+    Array.isArray(options.board) ? options.board : void 0
+  ].filter((value) => value !== void 0);
+  if (provided.length !== 1) {
+    throw new ValidationError("Exactly one of fen, pgn, or board must be provided");
+  }
+}
+function createRenderRequest(board, options) {
+  const normalized = normalizeRenderInputs(options);
+  return {
+    board,
+    theme: normalized.theme,
+    highlights: normalized.highlights,
+    size: normalized.size,
+    padding: normalized.padding,
+    borderSize: normalized.borderSize,
+    flipped: normalized.flipped,
+    colors: normalized.colors,
+    coordinates: normalized.coordinates
+  };
+}
+function createRenderRequestFromOptions(options) {
+  validateSingleInputSource(options);
+  const board = parseInputPosition(options);
+  return createRenderRequest(board, options);
+}
+
 // src/api/class-api.ts
 var ChessImageGenerator = class {
   position = null;
@@ -1047,65 +1362,70 @@ var ChessImageGenerator = class {
       throw new ValidationError("No board position loaded");
     }
     const renderer = new CanvasPngRenderer();
-    const normalized = normalizeRenderInputs({
+    const request = createRenderRequest(this.position, {
       ...this.defaults,
       highlights: this.highlights,
       highlightSquares: void 0
     });
-    return renderer.render({
-      board: this.position,
-      theme: normalized.theme,
-      highlights: normalized.highlights,
-      size: normalized.size,
-      padding: normalized.padding,
-      borderSize: normalized.borderSize,
-      flipped: normalized.flipped,
-      colors: normalized.colors,
-      coordinates: normalized.coordinates
-    });
+    return renderer.render(request);
   }
   async toFile(filePath) {
     const buffer = await this.toBuffer();
     await writeBufferToFile(filePath, buffer);
   }
-};
-
-// src/api/functional-api.ts
-function parseInputPosition(options) {
-  if (typeof options.fen === "string") {
-    return parseFEN(options.fen);
+  async toSvg() {
+    if (!this.position) {
+      throw new ValidationError("No board position loaded");
+    }
+    const renderer = new SvgRenderer();
+    const request = createRenderRequest(this.position, {
+      ...this.defaults,
+      highlights: this.highlights,
+      highlightSquares: void 0
+    });
+    return renderer.render(request);
   }
-  if (typeof options.pgn === "string") {
-    return parsePGN(options.pgn);
+  async toSvgFile(filePath) {
+    await writeStringToFile(filePath, await this.toSvg());
   }
-  if (Array.isArray(options.board)) {
-    return parseBoardArray(options.board);
+  async toJpeg() {
+    if (!this.position) {
+      throw new ValidationError("No board position loaded");
+    }
+    const renderer = new CanvasJpegRenderer();
+    const request = createRenderRequest(this.position, {
+      ...this.defaults,
+      highlights: this.highlights,
+      highlightSquares: void 0
+    });
+    return renderer.render(request);
   }
-  throw new ValidationError("Exactly one of fen, pgn, or board must be provided");
-}
-async function renderChess(options) {
-  const provided = [
-    typeof options.fen === "string" ? options.fen : void 0,
-    typeof options.pgn === "string" ? options.pgn : void 0,
-    Array.isArray(options.board) ? options.board : void 0
-  ].filter((value) => value !== void 0);
-  if (provided.length !== 1) {
-    throw new ValidationError("Exactly one of fen, pgn, or board must be provided");
+  async toJpegFile(filePath) {
+    await writeBufferToFile(filePath, await this.toJpeg());
   }
-  const position = parseInputPosition(options);
+};
+
+// src/api/functional-api.ts
+async function renderChess(options) {
   const renderer = new CanvasPngRenderer();
-  const normalized = normalizeRenderInputs(options);
-  return renderer.render({
-    board: position,
-    theme: normalized.theme,
-    highlights: normalized.highlights,
-    size: normalized.size,
-    padding: normalized.padding,
-    borderSize: normalized.borderSize,
-    flipped: normalized.flipped,
-    colors: normalized.colors,
-    coordinates: normalized.coordinates
-  });
+  return renderer.render(createRenderRequestFromOptions(options));
+}
+async function renderSvg(options) {
+  const renderer = new SvgRenderer();
+  return renderer.render(createRenderRequestFromOptions(options));
+}
+async function renderJpeg(options) {
+  const renderer = new CanvasJpegRenderer();
+  return renderer.render(createRenderRequestFromOptions(options));
+}
+async function renderFile(filePath, options) {
+  await writeBufferToFile(filePath, await renderChess(options));
+}
+async function renderSvgFile(filePath, options) {
+  await writeStringToFile(filePath, await renderSvg(options));
+}
+async function renderJpegFile(filePath, options) {
+  await writeBufferToFile(filePath, await renderJpeg(options));
 }
 export {
   ChessImageGenerator,
@@ -1115,6 +1435,11 @@ export {
   ThemeError,
   ValidationError,
   registerTheme,
-  renderChess
+  renderChess,
+  renderFile,
+  renderJpeg,
+  renderJpegFile,
+  renderSvg,
+  renderSvgFile
 };
 //# sourceMappingURL=index.js.map