@weasel-js/text 1.2.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 orochi235
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,44 @@
+# @weasel-js/text
+
+Typography for weasel: styled runs, style resolution, kerned glyph layout,
+wrap and measurement. Glyphs come from
+[`@weasel-js/font`](https://www.npmjs.com/package/@weasel-js/font); nothing
+here knows about a scene graph, a renderer or React.
+
+Part of [weasel](https://github.com/orochi235/weasel), a domain-agnostic 2D
+scene-graph canvas kit for React. See the
+[API reference](https://orochi235.github.io/weasel/api/).
+
+## Install
+
+```sh
+npm install @weasel-js/text
+```
+
+## Usage
+
+`layoutRuns` is the glyph walk: it takes fully-resolved runs and returns
+positioned geometry, grouped so that one group is one draw call.
+
+```ts
+import { toRuns, resolveTextStyle, resolveRuns, layoutRuns } from '@weasel-js/text';
+
+const style = resolveTextStyle({ fontFamily: 'inter', fontSize: 64 });
+const { groups, lines, bounds } = layoutRuns(resolveRuns(toRuns('Hello'), style), {
+  maxWidth: 900,
+  lineHeight: 1.2,
+  align: 'center',
+});
+```
+
+A group carries either textured quads (from a baked MSDF atlas) or outline
+glyphs — em-space SVG path data plus the pen position, baseline and scale to
+place it — for a consumer that tessellates its own geometry.
+
+Metrics come from whichever tier resolved the family: a baked MSDF atlas, or —
+for a family registered with `registerFontOutlines` and no atlas — the parsed
+face itself, so font bytes alone are enough to lay text out.
+
+The inline grammar `runsToMarkdown` / `markdownToRuns` speak is a parameter,
+defaulting to `MARKDOWN_RUN_GRAMMAR` (`**bold**`, `*italic*`, `***both***`).
+Pass a `RunGrammar` with different markers to read or write another spelling.

package/dist/chunk-4OGXTESY.js

@@ -0,0 +1,531 @@
+import { resolveFontVariant, glyphGeneration, glyphOutline, resolveGlyphFallback } from '@weasel-js/font';
+
+// src/layout/layoutRuns.ts
+var UNDERLINE_OFFSET = 0.1;
+var STRIKETHROUGH_OFFSET = -0.3;
+var OVERLINE_OFFSET = -0.9;
+var DECORATION_THICKNESS = 0.05;
+function atlasMetrics(font) {
+  return {
+    size: font.info.size,
+    base: font.common.base,
+    advanceOf: (cp) => font.charMap.get(cp)?.xadvance ?? null,
+    kernOf: (l, r) => font.kerningMap.get(l)?.get(r) ?? 0
+  };
+}
+function fillKey(p) {
+  if ("color" in p) return `s:${p.color}:${p.opacity ?? 1}`;
+  return `nx:${Math.random()}`;
+}
+function sameFill(a, b) {
+  if (a === b) return true;
+  if ("color" in a && "color" in b) {
+    return a.color === b.color && (a.opacity ?? 1) === (b.opacity ?? 1);
+  }
+  return false;
+}
+function strokePaints(s) {
+  if (s === void 0) return false;
+  const w = s.width ?? 1;
+  return (typeof w === "number" ? w : w.px) > 0;
+}
+function strokeKey(s) {
+  if (!s) return "-";
+  const width = s.width ?? 1;
+  return [
+    // A screen-pixel width keys apart from the equal world-unit number: the two
+    // resolve to different ribbons, so they must not share a draw call.
+    fillKey(s.paint),
+    typeof width === "number" ? width : `px${width.px}`,
+    s.join ?? "miter",
+    s.cap ?? "butt",
+    s.miterLimit ?? "",
+    s.align ?? "center",
+    (s.dash ?? []).join(",")
+  ].join(":");
+}
+function groupKey(family, weight, style, synthetic, fill, stroke, source, page) {
+  return `${family}|${weight}|${style}|${synthetic.bold ? 1 : 0}${synthetic.italic ? 1 : 0}|${fillKey(fill)}|${strokeKey(stroke)}|${source}|${page}`;
+}
+function getOrCreateGroup(ctx, run, resolved, page, sourceOverride) {
+  const atlasFamily = resolved.resolved.family;
+  const resolvedWeight = resolved.resolved.weight;
+  const resolvedStyle = resolved.resolved.style;
+  const source = sourceOverride ?? resolved.source;
+  const key = groupKey(
+    atlasFamily,
+    resolvedWeight,
+    resolvedStyle,
+    resolved.synthetic,
+    run.fill,
+    source === "outline" ? run.stroke : void 0,
+    source,
+    page
+  );
+  let g = ctx.groups.get(key);
+  if (!g) {
+    g = {
+      family: atlasFamily,
+      weight: resolvedWeight,
+      style: resolvedStyle,
+      synthetic: { ...resolved.synthetic },
+      source,
+      page,
+      fill: run.fill,
+      // Only the outline tier can paint it, and carrying it on an SDF group
+      // would be a promise the renderer cannot keep.
+      ...source === "outline" && run.stroke !== void 0 ? { stroke: run.stroke } : {},
+      quads: [],
+      glyphs: []
+    };
+    ctx.groups.set(key, g);
+  }
+  return g;
+}
+function resolveGlyph(run, font, resolved, cp) {
+  const direct = font.charMap.get(cp);
+  if (direct) return { glyph: direct, font, resolved };
+  const fallback = resolveGlyphFallback(run.fontFamily, run.fontWeight, run.fontStyle);
+  const face = fallback?.dynamicFace;
+  if (fallback && face) {
+    const glyph = face.requestGlyph(cp);
+    if (glyph.xadvance > 0 || glyph.width > 0) {
+      return { glyph, font: face.font, resolved: fallback };
+    }
+  }
+  warnMissingGlyphOnce(resolved.resolved.family, cp);
+  return null;
+}
+var warnedMissingGlyphs = /* @__PURE__ */ new Set();
+function warnMissingGlyphOnce(family, cp) {
+  const key = `${family}|${cp}`;
+  if (warnedMissingGlyphs.has(key)) return;
+  warnedMissingGlyphs.add(key);
+  const ch = String.fromCodePoint(cp);
+  console.warn(
+    `weasel layoutRuns: no glyph for U+${cp.toString(16).toUpperCase().padStart(4, "0")} (${JSON.stringify(ch)}) in "${family}", and the dynamic tier could not rasterize it \u2014 skipping the character. Bake it into the atlas, or call registerCanvasFont("${family}") to serve missing codepoints from installed fonts.`
+  );
+}
+function layoutRuns(runs, opts) {
+  const ctx = { groups: /* @__PURE__ */ new Map() };
+  const entries = [];
+  let prevCp;
+  let prevMetrics;
+  let prevFontSize;
+  let srcIndex = 0;
+  for (const run of runs) {
+    const resolved = resolveFontVariant(run.fontFamily, run.fontWeight, run.fontStyle);
+    const outlineFace = resolved.outlineFace;
+    const font = resolved.entry?.font ?? resolved.dynamicFace?.font ?? null;
+    const metrics = outlineFace ? { size: 1, base: outlineFace.ascender, advanceOf: (cp) => outlineFace.advanceOf(cp), kernOf: (l, r) => outlineFace.kernOf(l, r) } : font ? atlasMetrics(font) : void 0;
+    if (!metrics) {
+      srcIndex += run.text.length;
+      prevCp = void 0;
+      prevMetrics = void 0;
+      prevFontSize = void 0;
+      continue;
+    }
+    const scale = run.fontSize / metrics.size;
+    const tracking = run.letterSpacing;
+    for (const ch of [...run.text]) {
+      const cp = ch.codePointAt(0);
+      const isNewline = cp === 10;
+      const isSpace = cp === 32;
+      const srcStart = srcIndex;
+      const srcEnd = srcIndex + ch.length;
+      srcIndex = srcEnd;
+      if (isNewline) {
+        entries.push({
+          run,
+          font,
+          metrics,
+          glyph: { id: cp, x: 0, y: 0, width: 0, height: 0, xoffset: 0, yoffset: 0, xadvance: 0, page: 0 },
+          // A newline consumes no advance, so it takes no tracking either.
+          cp,
+          advance: 0,
+          tracking: 0,
+          kerningBefore: 0,
+          isSpace: false,
+          isNewline: true,
+          resolved,
+          fontSize: run.fontSize,
+          srcIndex: srcStart,
+          srcEnd
+        });
+        prevCp = void 0;
+        prevMetrics = void 0;
+        prevFontSize = void 0;
+        continue;
+      }
+      if (isSpace) {
+        const spaceGlyph = resolved.dynamicFace ? resolved.dynamicFace.requestGlyph(32) : font?.charMap.get(32) ?? null;
+        const spaceAdvance = spaceGlyph ? spaceGlyph.xadvance : metrics.advanceOf(32);
+        const advance = spaceAdvance !== null ? spaceAdvance * scale : run.fontSize * 0.25;
+        let kerningBefore2 = 0;
+        if (prevCp !== void 0 && prevMetrics !== void 0 && prevFontSize !== void 0) {
+          kerningBefore2 = prevMetrics.kernOf(prevCp, cp) * (prevFontSize / prevMetrics.size);
+        }
+        entries.push({
+          run,
+          font,
+          metrics,
+          glyph: spaceGlyph ?? { id: 32, x: 0, y: 0, width: 0, height: 0, xoffset: 0, yoffset: 0, xadvance: 0, page: 0 },
+          cp,
+          advance,
+          tracking,
+          kerningBefore: kerningBefore2,
+          isSpace: true,
+          isNewline: false,
+          resolved,
+          fontSize: run.fontSize,
+          srcIndex: srcStart,
+          srcEnd
+        });
+        prevCp = cp;
+        prevMetrics = metrics;
+        prevFontSize = run.fontSize;
+        continue;
+      }
+      if (outlineFace) {
+        const adv = metrics.advanceOf(cp);
+        if (adv === null) {
+          prevCp = cp;
+          prevMetrics = metrics;
+          prevFontSize = run.fontSize;
+          continue;
+        }
+        let kerningBefore2 = 0;
+        if (prevCp !== void 0 && prevMetrics !== void 0 && prevFontSize !== void 0) {
+          kerningBefore2 = prevMetrics.kernOf(prevCp, cp) * (prevFontSize / prevMetrics.size);
+        }
+        entries.push({
+          run,
+          font: null,
+          metrics,
+          glyph: null,
+          cp,
+          advance: adv * scale,
+          tracking,
+          kerningBefore: kerningBefore2,
+          isSpace,
+          isNewline: false,
+          resolved,
+          fontSize: run.fontSize,
+          srcIndex: srcStart,
+          srcEnd
+        });
+        prevCp = cp;
+        prevMetrics = metrics;
+        prevFontSize = run.fontSize;
+        continue;
+      }
+      const hit = resolved.dynamicFace ? { glyph: resolved.dynamicFace.requestGlyph(cp), font, resolved } : resolveGlyph(run, font, resolved, cp);
+      if (!hit) {
+        prevCp = cp;
+        prevMetrics = metrics;
+        prevFontSize = run.fontSize;
+        continue;
+      }
+      const glyphFont = hit.font;
+      const glyphMetrics = glyphFont === font ? metrics : atlasMetrics(glyphFont);
+      const glyphScale = run.fontSize / glyphFont.info.size;
+      let kerningBefore = 0;
+      if (prevCp !== void 0 && prevMetrics !== void 0 && prevFontSize !== void 0) {
+        kerningBefore = prevMetrics.kernOf(prevCp, cp) * (prevFontSize / prevMetrics.size);
+      }
+      entries.push({
+        run,
+        font: glyphFont,
+        metrics: glyphMetrics,
+        glyph: hit.glyph,
+        cp,
+        advance: hit.glyph.xadvance * glyphScale,
+        tracking,
+        kerningBefore,
+        isSpace,
+        isNewline: false,
+        resolved: hit.resolved,
+        fontSize: run.fontSize,
+        srcIndex: srcStart,
+        srcEnd
+      });
+      prevCp = cp;
+      prevMetrics = glyphMetrics;
+      prevFontSize = run.fontSize;
+    }
+  }
+  const lines = [];
+  let cur = { entries: [], width: 0, height: 0 };
+  function commitLine() {
+    lines.push(cur);
+    cur = { entries: [], width: 0, height: 0 };
+  }
+  let i = 0;
+  while (i < entries.length) {
+    const e = entries[i];
+    if (e.isNewline) {
+      if (cur.entries.length === 0) {
+        cur.height = Math.max(cur.height, e.fontSize * opts.lineHeight);
+        cur.blank = e;
+      }
+      commitLine();
+      i++;
+      continue;
+    }
+    if (e.isSpace) {
+      if (cur.entries.length > 0) {
+        cur.entries.push(e);
+        cur.width += e.kerningBefore + e.advance + e.tracking;
+        cur.height = Math.max(cur.height, e.fontSize * opts.lineHeight);
+      }
+      i++;
+      continue;
+    }
+    let j = i;
+    let wordWidth = 0;
+    while (j < entries.length && !entries[j].isSpace && !entries[j].isNewline) {
+      const w = entries[j];
+      wordWidth += w.kerningBefore + w.advance + w.tracking;
+      j++;
+    }
+    if (Number.isFinite(opts.maxWidth) && cur.width + wordWidth > opts.maxWidth && cur.entries.length > 0) {
+      commitLine();
+    }
+    for (let k = i; k < j; k++) {
+      const w = entries[k];
+      const kerningBefore = cur.entries.length === 0 ? 0 : w.kerningBefore;
+      cur.entries.push({ ...w, kerningBefore });
+      cur.width += kerningBefore + w.advance + w.tracking;
+      cur.height = Math.max(cur.height, w.fontSize * opts.lineHeight);
+    }
+    i = j;
+  }
+  if (cur.entries.length > 0) commitLine();
+  function outlineFor(e) {
+    const r0 = e.resolved.resolved;
+    if (e.resolved.source === "outline") {
+      return glyphOutline(r0.family, r0.weight, r0.style, e.cp);
+    }
+    const min = opts.outlineMinSize;
+    if (min === void 0) return null;
+    if (e.fontSize < min && !strokePaints(e.run.stroke)) return null;
+    if (e.resolved.synthetic.bold) return null;
+    const r = e.resolved.resolved;
+    return glyphOutline(r.family, r.weight, r.style, e.cp);
+  }
+  const decorations = [];
+  let span = null;
+  function flushSpan() {
+    const s = span;
+    span = null;
+    if (!s || s.x1 <= s.x0) return;
+    const thickness = s.fontSize * DECORATION_THICKNESS;
+    if (s.underline) {
+      const y0 = s.baselineY + s.fontSize * UNDERLINE_OFFSET;
+      decorations.push({ kind: "underline", x0: s.x0, y0, x1: s.x1, y1: y0 + thickness, fill: s.fill });
+    }
+    if (s.strikethrough) {
+      const y0 = s.baselineY + s.fontSize * STRIKETHROUGH_OFFSET;
+      decorations.push({ kind: "strikethrough", x0: s.x0, y0, x1: s.x1, y1: y0 + thickness, fill: s.fill });
+    }
+    if (s.overline) {
+      const y0 = s.baselineY + s.fontSize * OVERLINE_OFFSET;
+      decorations.push({ kind: "overline", x0: s.x0, y0, x1: s.x1, y1: y0 + thickness, fill: s.fill });
+    }
+  }
+  const lineBoxes = [];
+  let penY = 0;
+  let maxLineWidth = 0;
+  const finiteWidth = Number.isFinite(opts.maxWidth) ? opts.maxWidth : 0;
+  for (const line of lines) {
+    const alignShift = (() => {
+      if (opts.align === "left") return 0;
+      if (!Number.isFinite(opts.maxWidth)) {
+        return opts.align === "center" ? -line.width / 2 : -line.width;
+      }
+      const slack = finiteWidth - line.width;
+      return opts.align === "center" ? slack / 2 : slack;
+    })();
+    const lineX0 = alignShift;
+    let lineAscent = 0;
+    for (const e of line.entries) {
+      lineAscent = Math.max(lineAscent, e.metrics.base * (e.fontSize / e.metrics.size));
+    }
+    if (line.entries.length === 0 && line.blank) {
+      lineAscent = line.blank.metrics.base * (line.blank.fontSize / line.blank.metrics.size);
+    }
+    const lineBaselineY = penY + lineAscent;
+    const caretXs = [];
+    const caretIndices = [];
+    let penX = lineX0;
+    for (const e of line.entries) {
+      penX += e.kerningBefore;
+      caretXs.push(penX);
+      caretIndices.push(e.srcIndex);
+      const step = e.advance + e.tracking;
+      const scale = e.fontSize / e.metrics.size;
+      const baselineY = lineBaselineY - e.run.baselineShift;
+      if (e.run.underline || e.run.strikethrough || e.run.overline) {
+        if (span !== null && span.underline === e.run.underline && span.strikethrough === e.run.strikethrough && span.overline === e.run.overline && span.fontSize === e.fontSize && span.baselineY === baselineY && sameFill(span.fill, e.run.fill)) {
+          span.x1 = penX + step;
+        } else {
+          flushSpan();
+          span = {
+            underline: e.run.underline,
+            strikethrough: e.run.strikethrough,
+            overline: e.run.overline,
+            fill: e.run.fill,
+            fontSize: e.fontSize,
+            baselineY,
+            x0: penX,
+            x1: penX + step
+          };
+        }
+      } else {
+        flushSpan();
+      }
+      const outlineD = outlineFor(e);
+      if (outlineD !== null) {
+        const group2 = getOrCreateGroup(ctx, e.run, e.resolved, 0, "outline");
+        group2.glyphs.push({
+          d: outlineD,
+          key: `${e.resolved.resolved.family}|${e.resolved.resolved.weight}|${e.resolved.resolved.style}|${e.cp}`,
+          x: penX,
+          baselineY,
+          // Em space is unit-scale, so world units per em is just the size.
+          scale: e.fontSize
+        });
+        penX += step;
+        continue;
+      }
+      if (e.font === null || e.glyph === null || e.advance === 0 || e.glyph.width === 0 || e.glyph.page < 0) {
+        penX += step;
+        continue;
+      }
+      const group = getOrCreateGroup(ctx, e.run, e.resolved, e.glyph.page);
+      const atlasW = e.font.common.scaleW;
+      const atlasH = e.font.common.scaleH;
+      const qx0 = penX + e.glyph.xoffset * scale;
+      const qy0 = baselineY + (e.glyph.yoffset - e.metrics.base) * scale;
+      const qx1 = qx0 + e.glyph.width * scale;
+      const qy1 = qy0 + e.glyph.height * scale;
+      const u0 = e.glyph.x / atlasW;
+      const v0 = e.glyph.y / atlasH;
+      const u1 = (e.glyph.x + e.glyph.width) / atlasW;
+      const v1 = (e.glyph.y + e.glyph.height) / atlasH;
+      group.quads.push({ x0: qx0, y0: qy0, x1: qx1, y1: qy1, u0, v0, u1, v1, baselineY });
+      penX += step;
+    }
+    flushSpan();
+    const lastCell = line.entries[line.entries.length - 1];
+    caretXs.push(penX);
+    caretIndices.push(lastCell ? lastCell.srcEnd : line.blank?.srcIndex ?? 0);
+    lineBoxes.push({
+      x0: lineX0,
+      y0: penY,
+      x1: lineX0 + line.width,
+      y1: penY + line.height,
+      baselineY: lineBaselineY,
+      caretXs,
+      caretIndices
+    });
+    maxLineWidth = Math.max(maxLineWidth, line.width);
+    penY += line.height;
+  }
+  return {
+    groups: [...ctx.groups.values()],
+    decorations,
+    lines: lineBoxes,
+    bounds: { width: maxLineWidth, height: penY }
+  };
+}
+var LAYOUT_CACHE_VARIANT_LIMIT = 8;
+var LAYOUT_CACHE_STRUCTURAL_LIMIT = 64;
+var cache = /* @__PURE__ */ new WeakMap();
+var structural = /* @__PURE__ */ new Map();
+var structuralGeneration = -1;
+function outlineBucket(runs, min) {
+  if (min === void 0) return -1;
+  const sizes = /* @__PURE__ */ new Set();
+  for (const r of runs) sizes.add(r.fontSize);
+  let n = 0;
+  for (const size of sizes) if (size >= min) n++;
+  return n;
+}
+function variantKey(runs, opts) {
+  return `${opts.maxWidth}|${opts.lineHeight}|${opts.align}|${outlineBucket(runs, opts.outlineMinSize)}`;
+}
+var nextRefId = 1;
+var refIds = /* @__PURE__ */ new WeakMap();
+function refId(o) {
+  let id = refIds.get(o);
+  if (id === void 0) {
+    id = nextRefId++;
+    refIds.set(o, id);
+  }
+  return id;
+}
+function paintKey(p) {
+  return "color" in p ? `s${p.color}:${p.opacity ?? 1}` : `#${refId(p)}`;
+}
+function strokeKey2(s) {
+  if (!s) return "-";
+  const width = s.width ?? 1;
+  return [
+    paintKey(s.paint),
+    typeof width === "number" ? width : `px${width.px}`,
+    s.join ?? "miter",
+    s.cap ?? "butt",
+    s.miterLimit ?? "",
+    s.align ?? "center",
+    (s.dash ?? []).join(",")
+  ].join(":");
+}
+function runsKey(runs) {
+  let out = "";
+  for (const r of runs) {
+    out += `${r.text.length}:${r.text}|${r.fontFamily.length}:${r.fontFamily}|${r.fontSize}|${r.fontWeight}|${r.fontStyle}|${r.letterSpacing}|${r.underline ? 1 : 0}${r.strikethrough ? 1 : 0}${r.overline ? 1 : 0}|${r.baselineShift}|${paintKey(r.fill)}|${strokeKey2(r.stroke)}|`;
+  }
+  return out;
+}
+function cachedLayoutRuns(runs, opts) {
+  const fonts = glyphGeneration();
+  let entry = cache.get(runs);
+  if (entry === void 0) {
+    entry = { generation: fonts, byVariant: /* @__PURE__ */ new Map() };
+    cache.set(runs, entry);
+  } else if (entry.generation !== fonts) {
+    entry.generation = fonts;
+    entry.byVariant.clear();
+  }
+  const key = variantKey(runs, opts);
+  const hit = entry.byVariant.get(key);
+  if (hit !== void 0) return hit;
+  if (structuralGeneration !== fonts) {
+    structural.clear();
+    structuralGeneration = fonts;
+  }
+  const structuralK = `${runsKey(runs)}\0${key}`;
+  let laid = structural.get(structuralK);
+  if (laid !== void 0) {
+    structural.delete(structuralK);
+  } else {
+    laid = layoutRuns(runs, opts);
+    if (structural.size >= LAYOUT_CACHE_STRUCTURAL_LIMIT) {
+      structural.delete(structural.keys().next().value);
+    }
+  }
+  structural.set(structuralK, laid);
+  if (entry.byVariant.size >= LAYOUT_CACHE_VARIANT_LIMIT) entry.byVariant.clear();
+  entry.byVariant.set(key, laid);
+  return laid;
+}
+function _resetLayoutCacheForTests() {
+  cache = /* @__PURE__ */ new WeakMap();
+  structural = /* @__PURE__ */ new Map();
+  structuralGeneration = -1;
+}
+
+export { LAYOUT_CACHE_STRUCTURAL_LIMIT, LAYOUT_CACHE_VARIANT_LIMIT, _resetLayoutCacheForTests, cachedLayoutRuns, layoutRuns };
+//# sourceMappingURL=chunk-4OGXTESY.js.map
+//# sourceMappingURL=chunk-4OGXTESY.js.map