@antv/l7-layers 2.9.25-alpha.0 → 2.9.26-alpha.1

package/lib/utils/multiPassRender.js

@@ -1,53 +1,61 @@
-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
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-module.exports = __toCommonJS(multiPassRender_exports);
+exports.createMultiPassRenderer = createMultiPassRenderer;
+exports.normalizePasses = normalizePasses;
+
+var _slicedToArray2 = _interopRequireDefault(require("@babel/runtime/helpers/slicedToArray"));
+
+/**
+ * 'blurH' -> ['blurH', {}]
+ */
 function normalizePasses(passes) {
-  return passes.map((pass) => {
-    if (typeof pass === "string") {
+  return passes.map(function (pass) {
+    if (typeof pass === 'string') {
       pass = [pass, {}];
     }
+
     return pass;
   });
 }
+/**
+ * 默认添加 ClearPass、RenderPass
+ * 以及 PostProcessing 中的最后一个 CopyPass
+ */
+
+
 function createMultiPassRenderer(layer, passes, postProcessingPassFactory, normalPassFactory) {
-  const multiPassRenderer = layer.multiPassRenderer;
-  const { enablePicking, enableTAA } = layer.getLayerConfig();
+  var multiPassRenderer = layer.multiPassRenderer;
+
+  var _layer$getLayerConfig = layer.getLayerConfig(),
+      enablePicking = _layer$getLayerConfig.enablePicking,
+      enableTAA = _layer$getLayerConfig.enableTAA; // picking pass if enabled
+  // if (enablePicking) {
+  //   multiPassRenderer.add(normalPassFactory('pixelPicking'));
+  // }
+  // use TAA pass if enabled instead of render pass
+
+
   if (enableTAA) {
-    multiPassRenderer.add(normalPassFactory("taa"));
+    multiPassRenderer.add(normalPassFactory('taa'));
   } else {
-    multiPassRenderer.add(normalPassFactory("render"));
-  }
-  normalizePasses(passes).forEach((pass) => {
-    const [passName, initializationOptions] = pass;
+    // render all layers in this pass
+    multiPassRenderer.add(normalPassFactory('render'));
+  } // post processing
+
+
+  normalizePasses(passes).forEach(function (pass) {
+    var _pass = (0, _slicedToArray2.default)(pass, 2),
+        passName = _pass[0],
+        initializationOptions = _pass[1];
+
     multiPassRenderer.add(postProcessingPassFactory(passName), initializationOptions);
-  });
-  multiPassRenderer.add(postProcessingPassFactory("copy"));
+  }); // 末尾为固定的 CopyPass
+
+  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 +1,230 @@
-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
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-module.exports = __toCommonJS(polylineNormal_exports);
-var import_l7_utils = require("@antv/l7-utils");
-var import_gl_matrix = require("gl-matrix");
+exports.computeMiter = computeMiter;
+exports.computeNormal = computeNormal;
+exports.default = _default;
+exports.direction = direction;
+
+var _toConsumableArray2 = _interopRequireDefault(require("@babel/runtime/helpers/toConsumableArray"));
+
+var _l7Utils = require("@antv/l7-utils");
+
+var _glMatrix = 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);
+  _glMatrix.vec2.add(tangent, lineA, lineB);
+
+  _glMatrix.vec2.normalize(tangent, tangent);
+
+  miter = _glMatrix.vec2.fromValues(-tangent[1], tangent[0]);
+
+  var tmp = _glMatrix.vec2.fromValues(-lineA[1], lineA[0]);
+
+  return halfThick / _glMatrix.vec2.dot(miter, tmp);
 }
+
 function computeNormal(out, dir) {
-  return import_gl_matrix.vec2.set(out, -dir[1], dir[0]);
+  return _glMatrix.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);
+  // const a1 = aProjectFlat([a[0], a[1]]) as [number, number];
+  // const b1 = aProjectFlat([b[0], b[1]]) as [number, number];
+  _glMatrix.vec2.sub(out, a, b);
+
+  _glMatrix.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];
+  var dx = a1[0] - b1[0];
+  var 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];
+
+function _default(points, closed, indexOffset) {
+  var isDash = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : true;
+
+  var lineA = _glMatrix.vec2.fromValues(0, 0);
+
+  var lineB = _glMatrix.vec2.fromValues(0, 0);
+
+  var tangent = _glMatrix.vec2.fromValues(0, 0);
+
+  var miter = _glMatrix.vec2.create();
+
+  var started = false;
+  var lineNormal = null;
+
+  var tmp = _glMatrix.vec2.create();
+
+  var count = indexOffset || 0;
+  var miterLimit = 4;
+  var out = [];
+  var attrPos = [];
+  var attrIndex = [];
+  var miters = [];
+  var 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;
+
+  var total = points.length;
+
+  for (var i = 1; i < total; i++) {
+    var index = count;
+
+    var last = _glMatrix.vec2.fromValues(points[i - 1][0], points[i - 1][1]);
+
+    var cur = _glMatrix.vec2.fromValues(points[i][0], points[i][1]);
+
+    var next = i < points.length - 1 ? _glMatrix.vec2.fromValues(points[i + 1][0], points[i + 1][1]) : null; // 如果当前点和前一点相同，跳过
+
     if (isPointEqual(last, cur)) {
       continue;
     }
+
     if (next) {
-      let nextIndex = i + 1;
+      var 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;
+        next = nextIndex < points.length - 1 ? _glMatrix.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]]);
+
+    var d = 0;
+    var flatCur = (0, _l7Utils.aProjectFlat)([cur[0], cur[1]]);
+    var flatLast = (0, _l7Utils.aProjectFlat)([last[0], last[1]]);
+
     if (isDash) {
-      const lineDistance = lineSegmentDistance(flatCur, flatLast);
+      var lineDistance = lineSegmentDistance(flatCur, flatLast);
       d = lineDistance + attrDistance[attrDistance.length - 1];
     }
+
     direction(lineA, flatCur, flatLast);
+
     if (!lineNormal) {
-      lineNormal = import_gl_matrix.vec2.create();
+      lineNormal = _glMatrix.vec2.create();
       computeNormal(lineNormal, lineA);
     }
+
     if (!started) {
       started = true;
       extrusions(attrPos, out, miters, last, lineNormal, 1);
     }
-    attrIndex.push(index + 0, index + 2, index + 1);
+
+    attrIndex.push(index + 0, index + 2, index + 1); // no miter, simple segment
+
     if (!next) {
+      // reset normal
       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) {
+      var flatNext = (0, _l7Utils.aProjectFlat)([next[0], next[1]]); // get unit dir of next line
+
+      direction(lineB, flatNext, flatCur); // stores tangent & miter
+
+      var miterLen = computeMiter(tangent, _glMatrix.vec2.fromValues(miter[0], miter[1]), lineA, lineB, 1); // get orientation
+
+      var flip = _glMatrix.vec2.dot(tangent, lineNormal) < 0 ? -1 : 1;
+      var bevel = Math.abs(miterLen) > miterLimit; // 处理前后两条线段重合的情况，这种情况不需要使用任何接头（miter/bevel）。
+      // 理论上这种情况下 miterLen = Infinity，本应通过 isFinite(miterLen) 判断，
+      // 但是 AMap 投影变换后丢失精度，只能通过一个阈值（1000）判断。
+
+      if (Math.abs(miterLen) > 1000) {
         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);
+
+        _glMatrix.vec2.copy(lineNormal, tmp); // store normal for next round
+
+
         extrusions(attrPos, out, miters, cur, lineNormal, 1);
-        attrDistance.push(d, d, d, d);
+        attrDistance.push(d, d, d, d); // the miter is now the normal for our next join
+
         count += 4;
         continue;
       }
+
       if (bevel) {
-        miterLen = miterLimit;
+        miterLen = miterLimit; // next two points in our first segment
+
         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]);
+        attrIndex.push(index + 1, index + 2, index + 3); // now add the bevel triangle
+
+        attrIndex.push.apply(attrIndex, (0, _toConsumableArray2.default)(flip === 1 ? [index + 2, index + 4, index + 5] : [index + 4, index + 5, index + 3]));
         computeNormal(tmp, lineB);
-        import_gl_matrix.vec2.copy(lineNormal, tmp);
+
+        _glMatrix.vec2.copy(lineNormal, tmp); // store normal for next round
+
+
         extrusions(attrPos, out, miters, cur, lineNormal, 1);
-        attrDistance.push(d, d, d, d);
+        attrDistance.push(d, d, d, d); // the miter is now the normal for our next join
+
         count += 4;
       } else {
+        // next two points in our first segment
         extrusions(attrPos, out, miters, cur, lineNormal, 1);
-        attrIndex.push(index + 1, index + 2, index + 3);
+        attrIndex.push(index + 1, index + 2, index + 3); // now add the miter triangles
+
         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);
+
+        _glMatrix.vec2.copy(lineNormal, tmp); // store normal for next round
+
+
         extrusions(attrPos, out, miters, cur, lineNormal, 1);
-        attrDistance.push(d, d, d, d, d);
+        attrDistance.push(d, d, d, d, d); // the miter is now the normal for our next join
+
         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);
+
+  var pickData = [];
+
+  for (var _i = 0; _i < miters.length; _i++) {
+    var totalDistance = attrDistance[attrDistance.length - 1];
+    pickData.push(attrPos[_i * 3], attrPos[_i * 3 + 1], attrPos[_i * 3 + 2], attrDistance[_i], // dash
+    miters[_i], totalDistance // dash
+    );
   }
+
   return {
     normals: out,
-    attrIndex,
-    attrPos: pickData
+    attrIndex: attrIndex,
+    attrPos: pickData // [x,y,z, distance, miter ,t0tal ]
+
   };
-}
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
-  computeMiter,
-  computeNormal,
-  direction
-});
+} // [x,y,z, distance, miter ]

package/lib/utils/simpleLine.js

@@ -1,41 +1,39 @@
-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
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
 });
-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();
+exports.default = void 0;
+exports.direction = direction;
+
+var _classCallCheck2 = _interopRequireDefault(require("@babel/runtime/helpers/classCallCheck"));
+
+var _createClass2 = _interopRequireDefault(require("@babel/runtime/helpers/createClass"));
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _l7Utils = require("@antv/l7-utils");
+
+var _glMatrix = require("gl-matrix");
+
+var lineA = _glMatrix.vec2.create();
+
 function direction(out, a, b) {
-  import_gl_matrix.vec2.sub(out, a, b);
-  import_gl_matrix.vec2.normalize(out, out);
+  _glMatrix.vec2.sub(out, a, b);
+
+  _glMatrix.vec2.normalize(out, out);
+
   return out;
 }
-var ExtrudePolyline = class {
-  constructor() {
-    this.started = false;
-    this.totalDistance = 0;
-    this.currentIndex = 0;
+
+var ExtrudePolyline = /*#__PURE__*/function () {
+  function ExtrudePolyline() {
+    (0, _classCallCheck2.default)(this, ExtrudePolyline);
+    (0, _defineProperty2.default)(this, "started", false);
+    (0, _defineProperty2.default)(this, "totalDistance", 0);
+    (0, _defineProperty2.default)(this, "currentIndex", 0);
     this.complex = {
       positions: [],
       indices: [],
@@ -43,59 +41,76 @@ var ExtrudePolyline = class {
       indexes: []
     };
   }
-  simpleExtrude(points) {
-    const complex = this.complex;
-    if (points.length <= 1) {
+
+  (0, _createClass2.default)(ExtrudePolyline, [{
+    key: "simpleExtrude",
+    value: function simpleExtrude(points) {
+      var complex = this.complex;
+
+      if (points.length <= 1) {
+        return complex;
+      }
+
+      this.started = false;
+      this.totalDistance = 0;
+      var total = points.length;
+      var count = complex.startIndex;
+
+      for (var i = 1; i < total; i++) {
+        var last = points[i - 1];
+        var cur = points[i];
+        var amt = this.simpleSegment(complex, count, last, cur);
+        count += amt;
+      }
+
+      for (var _i = 0; _i < complex.positions.length / 6; _i++) {
+        complex.positions[_i * 6 + 5] = this.totalDistance;
+      }
+
       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;
+  }, {
+    key: "simpleSegment",
+    value: function simpleSegment(complex, index, last, cur) {
+      var count = 0;
+      var indices = complex.indices;
+      var positions = complex.positions;
+      var flatCur = (0, _l7Utils.aProjectFlat)([cur[0], cur[1]]);
+      var flatLast = (0, _l7Utils.aProjectFlat)([last[0], last[1]]);
+      direction(lineA, flatCur, flatLast);
+      var 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;
     }
-    for (let i = 0; i < complex.positions.length / 6; i++) {
-      complex.positions[i * 6 + 5] = this.totalDistance;
+  }, {
+    key: "extrusions",
+    value: function 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++;
     }
-    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);
+  }, {
+    key: "lineSegmentDistance",
+    value: function lineSegmentDistance(b1, a1) {
+      var dx = a1[0] - b1[0];
+      var dy = a1[1] - b1[1];
+      return Math.sqrt(dx * dx + dy * dy);
     }
-    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
-});
+  }]);
+  return ExtrudePolyline;
+}();
+
+exports.default = ExtrudePolyline;