@antv/l7-layers 2.9.24 → 2.9.26-alpha.0

package/lib/utils/layerData.js

@@ -1,156 +0,0 @@
-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;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target, mod));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/utils/layerData.ts
-var layerData_exports = {};
-__export(layerData_exports, {
-  calculateData: () => calculateData
-});
-module.exports = __toCommonJS(layerData_exports);
-var import_l7_maps = require("@antv/l7-maps");
-var import_l7_source = __toESM(require("@antv/l7-source"));
-var import_l7_utils = require("@antv/l7-utils");
-function getArrowPoints(p1, p2) {
-  const dir = [p2[0] - p1[0], p2[1] - p1[1]];
-  const normalizeDir = (0, import_l7_utils.normalize)(dir);
-  const arrowPoint = [
-    p1[0] + normalizeDir[0] * 1e-4,
-    p1[1] + normalizeDir[1] * 1e-4
-  ];
-  return arrowPoint;
-}
-function adjustData2Amap2Coordinates(mappedData, mapService) {
-  if (mappedData.length > 0 && mapService.version === import_l7_maps.Version["GAODE2.x"]) {
-    if (typeof mappedData[0].coordinates[0] === "number") {
-      mappedData.filter((d) => !d.originCoordinates).map((d) => {
-        d.version = import_l7_maps.Version["GAODE2.x"];
-        d.originCoordinates = cloneDeep(d.coordinates);
-        d.coordinates = this.mapService.lngLatToCoord(d.coordinates);
-      });
-    } else {
-      mappedData.filter((d) => !d.originCoordinates).map((d) => {
-        d.version = import_l7_maps.Version["GAODE2.x"];
-        d.originCoordinates = cloneDeep(d.coordinates);
-        d.coordinates = this.mapService.lngLatToCoords(d.coordinates);
-      });
-    }
-  }
-}
-function adjustData2SimpleCoordinates(mappedData, mapService) {
-  if (mappedData.length > 0 && mapService.version === import_l7_maps.Version.SIMPLE) {
-    mappedData.map((d) => {
-      if (!d.simpleCoordinate) {
-        d.coordinates = unProjectCoordinates(d.coordinates, mapService);
-        d.simpleCoordinate = true;
-      }
-    });
-  }
-}
-function unProjectCoordinates(coordinates, mapService) {
-  if (typeof coordinates[0] === "number") {
-    return mapService.simpleMapCoord.unproject(coordinates);
-  }
-  if (coordinates[0] && coordinates[0][0] instanceof Array) {
-    const coords = [];
-    coordinates.map((coord) => {
-      const c1 = [];
-      coord.map((co) => {
-        c1.push(mapService.simpleMapCoord.unproject(co));
-      });
-      coords.push(c1);
-    });
-    return coords;
-  } else {
-    const coords = [];
-    coordinates.map((coord) => {
-      coords.push(mapService.simpleMapCoord.unproject(coord));
-    });
-    return coords;
-  }
-}
-function applyAttributeMapping(attribute, record, minimumColor) {
-  var _a;
-  if (!attribute.scale) {
-    return [];
-  }
-  const scalers = ((_a = attribute == null ? void 0 : attribute.scale) == null ? void 0 : _a.scalers) || [];
-  const params = [];
-  scalers.forEach(({ field }) => {
-    var _a2;
-    if (record.hasOwnProperty(field) || ((_a2 = attribute.scale) == null ? void 0 : _a2.type) === "variable") {
-      params.push(record[field]);
-    }
-  });
-  const mappingResult = attribute.mapping ? attribute.mapping(params) : [];
-  if (attribute.name === "color" && !(0, import_l7_utils.isColor)(mappingResult[0])) {
-    return [minimumColor];
-  }
-  return mappingResult;
-}
-function mapping(attributes, data, fontService, mapService, minimumColor, layer) {
-  const {
-    arrow = {
-      enable: false
-    }
-  } = layer == null ? void 0 : layer.getLayerConfig();
-  const mappedData = data.map((record) => {
-    const encodeRecord = {
-      id: record._id,
-      coordinates: record.coordinates
-    };
-    attributes.filter((attribute) => attribute.scale !== void 0).forEach((attribute) => {
-      let values = applyAttributeMapping(attribute, record, minimumColor);
-      attribute.needRemapping = false;
-      if (attribute.name === "color") {
-        values = values.map((c) => {
-          return (0, import_l7_utils.rgb2arr)(c);
-        });
-      }
-      encodeRecord[attribute.name] = Array.isArray(values) && values.length === 1 ? values[0] : values;
-      if (attribute.name === "shape") {
-        encodeRecord.shape = fontService.getIconFontKey(encodeRecord[attribute.name]);
-      }
-    });
-    if (encodeRecord.shape === "line" && arrow.enable) {
-      const coords = encodeRecord.coordinates;
-      const arrowPoint = getArrowPoints(coords[0], coords[1]);
-      encodeRecord.coordinates.splice(1, 0, arrowPoint, arrowPoint);
-    }
-    return encodeRecord;
-  });
-  adjustData2Amap2Coordinates(mappedData, mapService);
-  adjustData2SimpleCoordinates(mappedData, mapService);
-  return mappedData;
-}
-function calculateData(layer, fontService, mapService, styleAttributeService, data, options) {
-  const source = new import_l7_source.default(data, options);
-  const bottomColor = layer.getBottomColor();
-  const attributes = styleAttributeService.getLayerStyleAttributes() || [];
-  const { dataArray } = source.data;
-  const filterData = dataArray;
-  const mappedEncodeData = mapping(attributes, filterData, fontService, mapService, bottomColor, layer);
-  source.destroy();
-  return mappedEncodeData;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  calculateData
-});

package/lib/utils/multiPassRender.js

@@ -1,53 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/utils/multiPassRender.ts
-var multiPassRender_exports = {};
-__export(multiPassRender_exports, {
-  createMultiPassRenderer: () => createMultiPassRenderer,
-  normalizePasses: () => normalizePasses
-});
-module.exports = __toCommonJS(multiPassRender_exports);
-function normalizePasses(passes) {
-  return passes.map((pass) => {
-    if (typeof pass === "string") {
-      pass = [pass, {}];
-    }
-    return pass;
-  });
-}
-function createMultiPassRenderer(layer, passes, postProcessingPassFactory, normalPassFactory) {
-  const multiPassRenderer = layer.multiPassRenderer;
-  const { enablePicking, enableTAA } = layer.getLayerConfig();
-  if (enableTAA) {
-    multiPassRenderer.add(normalPassFactory("taa"));
-  } else {
-    multiPassRenderer.add(normalPassFactory("render"));
-  }
-  normalizePasses(passes).forEach((pass) => {
-    const [passName, initializationOptions] = pass;
-    multiPassRenderer.add(postProcessingPassFactory(passName), initializationOptions);
-  });
-  multiPassRenderer.add(postProcessingPassFactory("copy"));
-  return multiPassRenderer;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  createMultiPassRenderer,
-  normalizePasses
-});

package/lib/utils/polylineNormal.js

@@ -1,178 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/utils/polylineNormal.ts
-var polylineNormal_exports = {};
-__export(polylineNormal_exports, {
-  computeMiter: () => computeMiter,
-  computeNormal: () => computeNormal,
-  default: () => polylineNormal_default,
-  direction: () => direction
-});
-module.exports = __toCommonJS(polylineNormal_exports);
-var import_l7_utils = require("@antv/l7-utils");
-var import_gl_matrix = require("gl-matrix");
-function computeMiter(tangent, miter, lineA, lineB, halfThick) {
-  import_gl_matrix.vec2.add(tangent, lineA, lineB);
-  import_gl_matrix.vec2.normalize(tangent, tangent);
-  miter = import_gl_matrix.vec2.fromValues(-tangent[1], tangent[0]);
-  const tmp = import_gl_matrix.vec2.fromValues(-lineA[1], lineA[0]);
-  return halfThick / import_gl_matrix.vec2.dot(miter, tmp);
-}
-function computeNormal(out, dir) {
-  return import_gl_matrix.vec2.set(out, -dir[1], dir[0]);
-}
-function direction(out, a, b) {
-  import_gl_matrix.vec2.sub(out, a, b);
-  import_gl_matrix.vec2.normalize(out, out);
-  return out;
-}
-function extrusions(positions, out, miters, point, normal, scale) {
-  addNext(out, miters, normal, -scale);
-  addNext(out, miters, normal, scale);
-  positions.push(point[0], point[1], 0);
-  positions.push(point[0], point[1], 0);
-}
-function addNext(out, miters, normal, length) {
-  out.push(normal[0], normal[1], 0);
-  miters.push(length);
-}
-function lineSegmentDistance(b1, a1) {
-  const dx = a1[0] - b1[0];
-  const dy = a1[1] - b1[1];
-  return Math.sqrt(dx * dx + dy * dy);
-}
-function isPointEqual(a, b) {
-  return a[0] === b[0] && a[1] === b[1];
-}
-function polylineNormal_default(points, closed, indexOffset, isDash = true) {
-  const lineA = import_gl_matrix.vec2.fromValues(0, 0);
-  const lineB = import_gl_matrix.vec2.fromValues(0, 0);
-  const tangent = import_gl_matrix.vec2.fromValues(0, 0);
-  const miter = import_gl_matrix.vec2.create();
-  let started = false;
-  let lineNormal = null;
-  const tmp = import_gl_matrix.vec2.create();
-  let count = indexOffset || 0;
-  const miterLimit = 4;
-  const out = [];
-  const attrPos = [];
-  const attrIndex = [];
-  const miters = [];
-  const attrDistance = [0, 0];
-  if (closed) {
-    points = points.slice();
-    points.push(points[0]);
-  }
-  const total = points.length;
-  for (let i = 1; i < total; i++) {
-    const index = count;
-    const last = import_gl_matrix.vec2.fromValues(points[i - 1][0], points[i - 1][1]);
-    const cur = import_gl_matrix.vec2.fromValues(points[i][0], points[i][1]);
-    let next = i < points.length - 1 ? import_gl_matrix.vec2.fromValues(points[i + 1][0], points[i + 1][1]) : null;
-    if (isPointEqual(last, cur)) {
-      continue;
-    }
-    if (next) {
-      let nextIndex = i + 1;
-      while (next && isPointEqual(cur, next)) {
-        next = nextIndex < points.length - 1 ? import_gl_matrix.vec2.fromValues(points[++nextIndex][0], points[nextIndex][1]) : null;
-      }
-    }
-    let d = 0;
-    const flatCur = (0, import_l7_utils.aProjectFlat)([cur[0], cur[1]]);
-    const flatLast = (0, import_l7_utils.aProjectFlat)([last[0], last[1]]);
-    if (isDash) {
-      const lineDistance = lineSegmentDistance(flatCur, flatLast);
-      d = lineDistance + attrDistance[attrDistance.length - 1];
-    }
-    direction(lineA, flatCur, flatLast);
-    if (!lineNormal) {
-      lineNormal = import_gl_matrix.vec2.create();
-      computeNormal(lineNormal, lineA);
-    }
-    if (!started) {
-      started = true;
-      extrusions(attrPos, out, miters, last, lineNormal, 1);
-    }
-    attrIndex.push(index + 0, index + 2, index + 1);
-    if (!next) {
-      computeNormal(lineNormal, lineA);
-      extrusions(attrPos, out, miters, cur, lineNormal, 1);
-      attrDistance.push(d, d);
-      attrIndex.push(index + 1, index + 2, index + 3);
-      count += 2;
-    } else {
-      const flatNext = (0, import_l7_utils.aProjectFlat)([next[0], next[1]]);
-      direction(lineB, flatNext, flatCur);
-      let miterLen = computeMiter(tangent, import_gl_matrix.vec2.fromValues(miter[0], miter[1]), lineA, lineB, 1);
-      const flip = import_gl_matrix.vec2.dot(tangent, lineNormal) < 0 ? -1 : 1;
-      const bevel = Math.abs(miterLen) > miterLimit;
-      if (Math.abs(miterLen) > 1e3) {
-        extrusions(attrPos, out, miters, cur, lineNormal, 1);
-        attrIndex.push(index + 1, index + 2, index + 3);
-        attrIndex.push(index + 2, index + 4, index + 3);
-        computeNormal(tmp, lineB);
-        import_gl_matrix.vec2.copy(lineNormal, tmp);
-        extrusions(attrPos, out, miters, cur, lineNormal, 1);
-        attrDistance.push(d, d, d, d);
-        count += 4;
-        continue;
-      }
-      if (bevel) {
-        miterLen = miterLimit;
-        extrusions(attrPos, out, miters, cur, lineNormal, 1);
-        attrIndex.push(index + 1, index + 2, index + 3);
-        attrIndex.push(...flip === 1 ? [index + 2, index + 4, index + 5] : [index + 4, index + 5, index + 3]);
-        computeNormal(tmp, lineB);
-        import_gl_matrix.vec2.copy(lineNormal, tmp);
-        extrusions(attrPos, out, miters, cur, lineNormal, 1);
-        attrDistance.push(d, d, d, d);
-        count += 4;
-      } else {
-        extrusions(attrPos, out, miters, cur, lineNormal, 1);
-        attrIndex.push(index + 1, index + 2, index + 3);
-        addNext(out, miters, lineNormal, miterLen * -flip);
-        attrPos.push(cur[0], cur[1], 0);
-        attrIndex.push(index + 2, index + 4, index + 3);
-        attrIndex.push(index + 4, index + 5, index + 6);
-        computeNormal(tmp, lineB);
-        import_gl_matrix.vec2.copy(lineNormal, tmp);
-        extrusions(attrPos, out, miters, cur, lineNormal, 1);
-        attrDistance.push(d, d, d, d, d);
-        count += 5;
-      }
-    }
-  }
-  const pickData = [];
-  for (let i = 0; i < miters.length; i++) {
-    const totalDistance = attrDistance[attrDistance.length - 1];
-    pickData.push(attrPos[i * 3], attrPos[i * 3 + 1], attrPos[i * 3 + 2], attrDistance[i], miters[i], totalDistance);
-  }
-  return {
-    normals: out,
-    attrIndex,
-    attrPos: pickData
-  };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  computeMiter,
-  computeNormal,
-  direction
-});

package/lib/utils/simpleLine.js

@@ -1,101 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/utils/simpleLine.ts
-var simpleLine_exports = {};
-__export(simpleLine_exports, {
-  default: () => ExtrudePolyline,
-  direction: () => direction
-});
-module.exports = __toCommonJS(simpleLine_exports);
-var import_l7_utils = require("@antv/l7-utils");
-var import_gl_matrix = require("gl-matrix");
-var lineA = import_gl_matrix.vec2.create();
-function direction(out, a, b) {
-  import_gl_matrix.vec2.sub(out, a, b);
-  import_gl_matrix.vec2.normalize(out, out);
-  return out;
-}
-var ExtrudePolyline = class {
-  constructor() {
-    this.started = false;
-    this.totalDistance = 0;
-    this.currentIndex = 0;
-    this.complex = {
-      positions: [],
-      indices: [],
-      startIndex: 0,
-      indexes: []
-    };
-  }
-  simpleExtrude(points) {
-    const complex = this.complex;
-    if (points.length <= 1) {
-      return complex;
-    }
-    this.started = false;
-    this.totalDistance = 0;
-    const total = points.length;
-    let count = complex.startIndex;
-    for (let i = 1; i < total; i++) {
-      const last = points[i - 1];
-      const cur = points[i];
-      const amt = this.simpleSegment(complex, count, last, cur);
-      count += amt;
-    }
-    for (let i = 0; i < complex.positions.length / 6; i++) {
-      complex.positions[i * 6 + 5] = this.totalDistance;
-    }
-    return complex;
-  }
-  simpleSegment(complex, index, last, cur) {
-    let count = 0;
-    const indices = complex.indices;
-    const positions = complex.positions;
-    const flatCur = (0, import_l7_utils.aProjectFlat)([cur[0], cur[1]]);
-    const flatLast = (0, import_l7_utils.aProjectFlat)([last[0], last[1]]);
-    direction(lineA, flatCur, flatLast);
-    const segmentDistance = this.lineSegmentDistance(flatCur, flatLast);
-    this.totalDistance += segmentDistance;
-    if (!this.started) {
-      this.started = true;
-      this.extrusions(positions, last, this.totalDistance - segmentDistance);
-    }
-    this.extrusions(positions, cur, this.totalDistance);
-    indices.push(index + 0, index + 1, index + 2);
-    indices.push(index + 2, index + 1, index + 3);
-    count += 2;
-    return count;
-  }
-  extrusions(positions, point, distanceRadio) {
-    positions.push(point[0], point[1], point[2] | 0, distanceRadio, 0, point[2] | 0);
-    this.complex.indexes.push(this.currentIndex);
-    positions.push(point[0], point[1], point[2] | 0, distanceRadio, 0, point[2] | 0);
-    this.complex.indexes.push(this.currentIndex);
-    this.currentIndex++;
-  }
-  lineSegmentDistance(b1, a1) {
-    const dx = a1[0] - b1[0];
-    const dy = a1[1] - b1[1];
-    return Math.sqrt(dx * dx + dy * dy);
-  }
-};
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  direction
-});

package/lib/utils/symbol-layout.js

@@ -1,205 +0,0 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-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;
-};
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
-
-// src/utils/symbol-layout.ts
-var symbol_layout_exports = {};
-__export(symbol_layout_exports, {
-  getGlyphQuads: () => getGlyphQuads,
-  shapeText: () => shapeText
-});
-module.exports = __toCommonJS(symbol_layout_exports);
-function getAnchorAlignment(anchor) {
-  let horizontalAlign = 0.5;
-  let verticalAlign = 0.5;
-  switch (anchor) {
-    case "right":
-    case "top-right":
-    case "bottom-right":
-      horizontalAlign = 1;
-      break;
-    case "left":
-    case "top-left":
-    case "bottom-left":
-      horizontalAlign = 0;
-      break;
-    default:
-      horizontalAlign = 0.5;
-  }
-  switch (anchor) {
-    case "bottom":
-    case "bottom-right":
-    case "bottom-left":
-      verticalAlign = 1;
-      break;
-    case "top":
-    case "top-right":
-    case "top-left":
-      verticalAlign = 0;
-      break;
-    default:
-      verticalAlign = 0.5;
-  }
-  return { horizontalAlign, verticalAlign };
-}
-function justifyLine(positionedGlyphs, glyphMap, start, end, justify) {
-  if (!justify) {
-    return;
-  }
-  const lastPositionedGlyph = positionedGlyphs[end];
-  const glyph = lastPositionedGlyph.glyph;
-  if (glyph) {
-    const lastAdvance = glyphMap[glyph].advance * lastPositionedGlyph.scale;
-    const lineIndent = (positionedGlyphs[end].x + lastAdvance) * justify;
-    for (let j = start; j <= end; j++) {
-      positionedGlyphs[j].x -= lineIndent;
-    }
-  }
-}
-function align(positionedGlyphs, justify, horizontalAlign, verticalAlign, maxLineLength, lineHeight, lineCount) {
-  const shiftX = (justify - horizontalAlign) * maxLineLength;
-  const shiftY = (-verticalAlign * lineCount + 0.5) * lineHeight;
-  for (const glyphs of positionedGlyphs) {
-    glyphs.x += shiftX;
-    glyphs.y += shiftY;
-  }
-}
-function shapeLines(shaping, glyphMap, lines, lineHeight, textAnchor, textJustify, spacing) {
-  const yOffset = -8;
-  let x = 0;
-  let y = yOffset;
-  let maxLineLength = 0;
-  const positionedGlyphs = shaping.positionedGlyphs;
-  const justify = textJustify === "right" ? 1 : textJustify === "left" ? 0 : 0.5;
-  const lineStartIndex = positionedGlyphs.length;
-  lines.forEach((line) => {
-    line.split("").forEach((char) => {
-      const glyph = glyphMap[char];
-      const baselineOffset = 0;
-      if (glyph) {
-        positionedGlyphs.push({
-          glyph: char,
-          x,
-          y: y + baselineOffset,
-          vertical: false,
-          scale: 1,
-          metrics: glyph
-        });
-        x += glyph.advance + spacing;
-      }
-    });
-    if (positionedGlyphs.length !== lineStartIndex) {
-      const lineLength = x - spacing;
-      maxLineLength = Math.max(lineLength, maxLineLength);
-      justifyLine(positionedGlyphs, glyphMap, lineStartIndex, positionedGlyphs.length - 1, justify);
-    }
-    x = 0;
-    y -= lineHeight + 5;
-  });
-  const { horizontalAlign, verticalAlign } = getAnchorAlignment(textAnchor);
-  align(positionedGlyphs, justify, horizontalAlign, verticalAlign, maxLineLength, lineHeight, lines.length);
-  const height = y - yOffset;
-  shaping.top += -verticalAlign * height;
-  shaping.bottom = shaping.top - height;
-  shaping.left += -horizontalAlign * maxLineLength;
-  shaping.right = shaping.left + maxLineLength;
-}
-function shapeIconFont(shaping, glyphMap, iconfonts, lineHeight, textAnchor, textJustify, spacing) {
-  const yOffset = -8;
-  let x = 0;
-  let y = yOffset;
-  let maxLineLength = 0;
-  const positionedGlyphs = shaping.positionedGlyphs;
-  const justify = textJustify === "right" ? 1 : textJustify === "left" ? 0 : 0.5;
-  const lineStartIndex = positionedGlyphs.length;
-  iconfonts.forEach((iconfont) => {
-    const glyph = glyphMap[iconfont];
-    const baselineOffset = 0;
-    if (glyph) {
-      positionedGlyphs.push({
-        glyph: iconfont,
-        x: glyph.advance / 2,
-        y: y + baselineOffset,
-        vertical: false,
-        scale: 1,
-        metrics: glyph
-      });
-      x += glyph.advance + spacing;
-    }
-    if (positionedGlyphs.length !== lineStartIndex) {
-      const lineLength = x - spacing;
-      maxLineLength = Math.max(lineLength, maxLineLength);
-      justifyLine(positionedGlyphs, glyphMap, lineStartIndex, positionedGlyphs.length - 1, justify);
-    }
-    x = 0;
-    y -= lineHeight + 5;
-  });
-  const { horizontalAlign, verticalAlign } = getAnchorAlignment(textAnchor);
-  align(positionedGlyphs, justify, horizontalAlign, verticalAlign, maxLineLength, lineHeight, iconfonts.length);
-  const height = y - yOffset;
-  shaping.top += -verticalAlign * height;
-  shaping.bottom = shaping.top - height;
-  shaping.left += -horizontalAlign * maxLineLength;
-  shaping.right = shaping.left + maxLineLength;
-}
-function shapeText(text, glyphs, lineHeight, textAnchor, textJustify, spacing, translate = [0, 0], isIconFont) {
-  const lines = text.split("\n");
-  const positionedGlyphs = [];
-  const shaping = {
-    positionedGlyphs,
-    top: translate[1],
-    bottom: translate[1],
-    left: translate[0],
-    right: translate[0],
-    lineCount: lines.length,
-    text
-  };
-  isIconFont ? shapeIconFont(shaping, glyphs, lines, lineHeight, textAnchor, textJustify, spacing) : shapeLines(shaping, glyphs, lines, lineHeight, textAnchor, textJustify, spacing);
-  if (!positionedGlyphs.length) {
-    return false;
-  }
-  return shaping;
-}
-function getGlyphQuads(shaping, textOffset = [0, 0], alongLine) {
-  const { positionedGlyphs = [] } = shaping;
-  const quads = [];
-  for (const positionedGlyph of positionedGlyphs) {
-    const rect = positionedGlyph.metrics;
-    const rectBuffer = 4;
-    const halfAdvance = rect.advance * positionedGlyph.scale / 2;
-    const glyphOffset = alongLine ? [positionedGlyph.x + halfAdvance, positionedGlyph.y] : [0, 0];
-    const builtInOffset = alongLine ? [0, 0] : [
-      positionedGlyph.x + halfAdvance + textOffset[0],
-      positionedGlyph.y + textOffset[1]
-    ];
-    const x1 = (0 - rectBuffer) * positionedGlyph.scale - halfAdvance + builtInOffset[0];
-    const y1 = (0 - rectBuffer) * positionedGlyph.scale + builtInOffset[1];
-    const x2 = x1 + rect.width * positionedGlyph.scale;
-    const y2 = y1 + rect.height * positionedGlyph.scale;
-    const tl = { x: x1, y: y1 };
-    const tr = { x: x2, y: y1 };
-    const bl = { x: x1, y: y2 };
-    const br = { x: x2, y: y2 };
-    quads.push({ tl, tr, bl, br, tex: rect, glyphOffset });
-  }
-  return quads;
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  getGlyphQuads,
-  shapeText
-});