@loaders.gl/wkt 3.1.1 → 3.1.5

package/dist/bundle.js

@@ -1,596 +1,5 @@
-(() => {
-  var __defProp = Object.defineProperty;
-  var __markAsModule = (target) => __defProp(target, "__esModule", { value: true });
-  var __esm = (fn, res) => function __init() {
-    return fn && (res = (0, fn[Object.keys(fn)[0]])(fn = 0)), res;
-  };
-  var __commonJS = (cb, mod) => function __require() {
-    return mod || (0, cb[Object.keys(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-  };
-  var __export = (target, all) => {
-    __markAsModule(target);
-    for (var name in all)
-      __defProp(target, name, { get: all[name], enumerable: true });
-  };
-
-  // src/lib/utils/version.ts
-  var VERSION;
-  var init_version = __esm({
-    "src/lib/utils/version.ts"() {
-      VERSION = typeof __VERSION__ !== "undefined" ? __VERSION__ : "latest";
-    }
-  });
-
-  // src/lib/parse-wkb.ts
-  function parseWKB(arrayBuffer) {
-    const view = new DataView(arrayBuffer);
-    let offset = 0;
-    const littleEndian = view.getUint8(offset) === 1;
-    offset++;
-    const geometryCode = view.getUint32(offset, littleEndian);
-    offset += 4;
-    const geometryType = geometryCode % 1e3;
-    const type = (geometryCode - geometryType) / 1e3;
-    const dimension = NUM_DIMENSIONS[type];
-    switch (geometryType) {
-      case 1:
-        const point = parsePoint(view, offset, dimension, littleEndian);
-        return point.geometry;
-      case 2:
-        const line = parseLineString(view, offset, dimension, littleEndian);
-        return line.geometry;
-      case 3:
-        const polygon = parsePolygon(view, offset, dimension, littleEndian);
-        return polygon.geometry;
-      case 4:
-        const multiPoint = parseMultiPoint(view, offset, dimension, littleEndian);
-        multiPoint.type = "Point";
-        return multiPoint;
-      case 5:
-        const multiLine = parseMultiLineString(view, offset, dimension, littleEndian);
-        multiLine.type = "LineString";
-        return multiLine;
-      case 6:
-        const multiPolygon = parseMultiPolygon(view, offset, dimension, littleEndian);
-        multiPolygon.type = "Polygon";
-        return multiPolygon;
-      default:
-        throw new Error(`WKB: Unsupported geometry type: ${geometryType}`);
-    }
-  }
-  function parsePoint(view, offset, dimension, littleEndian) {
-    const positions = new Float64Array(dimension);
-    for (let i = 0; i < dimension; i++) {
-      positions[i] = view.getFloat64(offset, littleEndian);
-      offset += 8;
-    }
-    return {
-      geometry: { type: "Point", positions: { value: positions, size: dimension } },
-      offset
-    };
-  }
-  function parseLineString(view, offset, dimension, littleEndian) {
-    const nPoints = view.getUint32(offset, littleEndian);
-    offset += 4;
-    const positions = new Float64Array(nPoints * dimension);
-    for (let i = 0; i < nPoints * dimension; i++) {
-      positions[i] = view.getFloat64(offset, littleEndian);
-      offset += 8;
-    }
-    const pathIndices = [0];
-    if (nPoints > 0) {
-      pathIndices.push(nPoints);
-    }
-    return {
-      geometry: {
-        type: "LineString",
-        positions: { value: positions, size: dimension },
-        pathIndices: { value: new Uint16Array(pathIndices), size: 1 }
-      },
-      offset
-    };
-  }
-  function parsePolygon(view, offset, dimension, littleEndian) {
-    const nRings = view.getUint32(offset, littleEndian);
-    offset += 4;
-    const rings = [];
-    for (let i = 0; i < nRings; i++) {
-      const parsed = parseLineString(view, offset, dimension, littleEndian);
-      const { positions } = parsed.geometry;
-      offset = parsed.offset;
-      rings.push(positions.value);
-    }
-    const concatenatedPositions = new Float64Array(concatTypedArrays(rings).buffer);
-    const polygonIndices = [0];
-    if (concatenatedPositions.length > 0) {
-      polygonIndices.push(concatenatedPositions.length / dimension);
-    }
-    const primitivePolygonIndices = rings.map((l) => l.length / dimension).map(cumulativeSum(0));
-    primitivePolygonIndices.unshift(0);
-    return {
-      geometry: {
-        type: "Polygon",
-        positions: { value: concatenatedPositions, size: dimension },
-        polygonIndices: {
-          value: new Uint16Array(polygonIndices),
-          size: 1
-        },
-        primitivePolygonIndices: { value: new Uint16Array(primitivePolygonIndices), size: 1 }
-      },
-      offset
-    };
-  }
-  function parseMultiPoint(view, offset, dimension, littleEndian) {
-    const nPoints = view.getUint32(offset, littleEndian);
-    offset += 4;
-    const binaryPointGeometries = [];
-    for (let i = 0; i < nPoints; i++) {
-      const littleEndianPoint = view.getUint8(offset) === 1;
-      offset++;
-      if (view.getUint32(offset, littleEndianPoint) % 1e3 !== 1) {
-        throw new Error("WKB: Inner geometries of MultiPoint not of type Point");
-      }
-      offset += 4;
-      const parsed = parsePoint(view, offset, dimension, littleEndianPoint);
-      offset = parsed.offset;
-      binaryPointGeometries.push(parsed.geometry);
-    }
-    return concatenateBinaryPointGeometries(binaryPointGeometries, dimension);
-  }
-  function parseMultiLineString(view, offset, dimension, littleEndian) {
-    const nLines = view.getUint32(offset, littleEndian);
-    offset += 4;
-    const binaryLineGeometries = [];
-    for (let i = 0; i < nLines; i++) {
-      const littleEndianLine = view.getUint8(offset) === 1;
-      offset++;
-      if (view.getUint32(offset, littleEndianLine) % 1e3 !== 2) {
-        throw new Error("WKB: Inner geometries of MultiLineString not of type LineString");
-      }
-      offset += 4;
-      const parsed = parseLineString(view, offset, dimension, littleEndianLine);
-      offset = parsed.offset;
-      binaryLineGeometries.push(parsed.geometry);
-    }
-    return concatenateBinaryLineGeometries(binaryLineGeometries, dimension);
-  }
-  function parseMultiPolygon(view, offset, dimension, littleEndian) {
-    const nPolygons = view.getUint32(offset, littleEndian);
-    offset += 4;
-    const binaryPolygonGeometries = [];
-    for (let i = 0; i < nPolygons; i++) {
-      const littleEndianPolygon = view.getUint8(offset) === 1;
-      offset++;
-      if (view.getUint32(offset, littleEndianPolygon) % 1e3 !== 3) {
-        throw new Error("WKB: Inner geometries of MultiPolygon not of type Polygon");
-      }
-      offset += 4;
-      const parsed = parsePolygon(view, offset, dimension, littleEndianPolygon);
-      offset = parsed.offset;
-      binaryPolygonGeometries.push(parsed.geometry);
-    }
-    return concatenateBinaryPolygonGeometries(binaryPolygonGeometries, dimension);
-  }
-  function concatenateBinaryPointGeometries(binaryPointGeometries, dimension) {
-    const positions = binaryPointGeometries.map((geometry) => geometry.positions.value);
-    const concatenatedPositions = new Float64Array(concatTypedArrays(positions).buffer);
-    return {
-      type: "Point",
-      positions: { value: concatenatedPositions, size: dimension }
-    };
-  }
-  function concatenateBinaryLineGeometries(binaryLineGeometries, dimension) {
-    const lines = binaryLineGeometries.map((geometry) => geometry.positions.value);
-    const concatenatedPositions = new Float64Array(concatTypedArrays(lines).buffer);
-    const pathIndices = lines.map((line) => line.length / dimension).map(cumulativeSum(0));
-    pathIndices.unshift(0);
-    return {
-      type: "LineString",
-      positions: { value: concatenatedPositions, size: dimension },
-      pathIndices: { value: new Uint16Array(pathIndices), size: 1 }
-    };
-  }
-  function concatenateBinaryPolygonGeometries(binaryPolygonGeometries, dimension) {
-    const polygons = [];
-    const primitivePolygons = [];
-    for (const binaryPolygon of binaryPolygonGeometries) {
-      const { positions, primitivePolygonIndices: primitivePolygonIndices2 } = binaryPolygon;
-      polygons.push(positions.value);
-      primitivePolygons.push(primitivePolygonIndices2.value);
-    }
-    const concatenatedPositions = new Float64Array(concatTypedArrays(polygons).buffer);
-    const polygonIndices = polygons.map((p) => p.length / dimension).map(cumulativeSum(0));
-    polygonIndices.unshift(0);
-    const primitivePolygonIndices = [0];
-    for (const primitivePolygon of primitivePolygons) {
-      primitivePolygonIndices.push(...primitivePolygon.filter((x) => x > 0).map((x) => x + primitivePolygonIndices[primitivePolygonIndices.length - 1]));
-    }
-    return {
-      type: "Polygon",
-      positions: { value: concatenatedPositions, size: dimension },
-      polygonIndices: { value: new Uint16Array(polygonIndices), size: 1 },
-      primitivePolygonIndices: { value: new Uint16Array(primitivePolygonIndices), size: 1 }
-    };
-  }
-  function concatTypedArrays(arrays) {
-    let byteLength = 0;
-    for (let i = 0; i < arrays.length; ++i) {
-      byteLength += arrays[i].byteLength;
-    }
-    const buffer = new Uint8Array(byteLength);
-    let byteOffset = 0;
-    for (let i = 0; i < arrays.length; ++i) {
-      const data = new Uint8Array(arrays[i].buffer);
-      byteLength = data.length;
-      for (let j = 0; j < byteLength; ++j) {
-        buffer[byteOffset++] = data[j];
-      }
-    }
-    return buffer;
-  }
-  var NUM_DIMENSIONS, cumulativeSum;
-  var init_parse_wkb = __esm({
-    "src/lib/parse-wkb.ts"() {
-      NUM_DIMENSIONS = {
-        0: 2,
-        1: 3,
-        2: 3,
-        3: 4
-      };
-      cumulativeSum = (sum) => (value) => sum += value;
-    }
-  });
-
-  // src/wkb-loader.ts
-  var WKBWorkerLoader, WKBLoader;
-  var init_wkb_loader = __esm({
-    "src/wkb-loader.ts"() {
-      init_version();
-      init_parse_wkb();
-      WKBWorkerLoader = {
-        name: "WKB",
-        id: "wkb",
-        module: "wkt",
-        version: VERSION,
-        worker: true,
-        category: "geometry",
-        extensions: ["wkb"],
-        mimeTypes: [],
-        options: {
-          wkb: {}
-        }
-      };
-      WKBLoader = {
-        ...WKBWorkerLoader,
-        parse: async (arrayBuffer) => parseWKB(arrayBuffer),
-        parseSync: parseWKB
-      };
-    }
-  });
-
-  // src/lib/parse-wkt.ts
-  function parseWKT(input) {
-    const parts = input.split(";");
-    let _ = parts.pop();
-    const srid = (parts.shift() || "").split("=").pop();
-    let i = 0;
-    function $(re) {
-      const match = _.substring(i).match(re);
-      if (!match)
-        return null;
-      else {
-        i += match[0].length;
-        return match[0];
-      }
-    }
-    function crs(obj) {
-      if (obj && srid.match(/\d+/)) {
-        obj.crs = {
-          type: "name",
-          properties: {
-            name: "urn:ogc:def:crs:EPSG::" + srid
-          }
-        };
-      }
-      return obj;
-    }
-    function white() {
-      $(/^\s*/);
-    }
-    function multicoords() {
-      white();
-      let depth = 0;
-      const rings = [];
-      const stack = [rings];
-      let pointer = rings;
-      let elem;
-      while (elem = $(/^(\()/) || $(/^(\))/) || $(/^(,)/) || $(tuples)) {
-        if (elem === "(") {
-          stack.push(pointer);
-          pointer = [];
-          stack[stack.length - 1].push(pointer);
-          depth++;
-        } else if (elem === ")") {
-          if (pointer.length === 0)
-            return null;
-          pointer = stack.pop();
-          if (!pointer)
-            return null;
-          depth--;
-          if (depth === 0)
-            break;
-        } else if (elem === ",") {
-          pointer = [];
-          stack[stack.length - 1].push(pointer);
-        } else if (!elem.split(/\s/g).some(isNaN)) {
-          Array.prototype.push.apply(pointer, elem.split(/\s/g).map(parseFloat));
-        } else {
-          return null;
-        }
-        white();
-      }
-      if (depth !== 0)
-        return null;
-      return rings;
-    }
-    function coords() {
-      const list = [];
-      let item;
-      let pt;
-      while (pt = $(tuples) || $(/^(,)/)) {
-        if (pt === ",") {
-          list.push(item);
-          item = [];
-        } else if (!pt.split(/\s/g).some(isNaN)) {
-          if (!item)
-            item = [];
-          Array.prototype.push.apply(item, pt.split(/\s/g).map(parseFloat));
-        }
-        white();
-      }
-      if (item)
-        list.push(item);
-      else
-        return null;
-      return list.length ? list : null;
-    }
-    function point() {
-      if (!$(/^(point(\sz)?)/i))
-        return null;
-      white();
-      if (!$(/^(\()/))
-        return null;
-      const c = coords();
-      if (!c)
-        return null;
-      white();
-      if (!$(/^(\))/))
-        return null;
-      return {
-        type: "Point",
-        coordinates: c[0]
-      };
-    }
-    function multipoint() {
-      if (!$(/^(multipoint)/i))
-        return null;
-      white();
-      const newCoordsFormat = _.substring(_.indexOf("(") + 1, _.length - 1).replace(/\(/g, "").replace(/\)/g, "");
-      _ = "MULTIPOINT (" + newCoordsFormat + ")";
-      const c = multicoords();
-      if (!c)
-        return null;
-      white();
-      return {
-        type: "MultiPoint",
-        coordinates: c
-      };
-    }
-    function multilinestring() {
-      if (!$(/^(multilinestring)/i))
-        return null;
-      white();
-      const c = multicoords();
-      if (!c)
-        return null;
-      white();
-      return {
-        type: "MultiLineString",
-        coordinates: c
-      };
-    }
-    function linestring() {
-      if (!$(/^(linestring(\sz)?)/i))
-        return null;
-      white();
-      if (!$(/^(\()/))
-        return null;
-      const c = coords();
-      if (!c)
-        return null;
-      if (!$(/^(\))/))
-        return null;
-      return {
-        type: "LineString",
-        coordinates: c
-      };
-    }
-    function polygon() {
-      if (!$(/^(polygon(\sz)?)/i))
-        return null;
-      white();
-      const c = multicoords();
-      if (!c)
-        return null;
-      return {
-        type: "Polygon",
-        coordinates: c
-      };
-    }
-    function multipolygon() {
-      if (!$(/^(multipolygon)/i))
-        return null;
-      white();
-      const c = multicoords();
-      if (!c)
-        return null;
-      return {
-        type: "MultiPolygon",
-        coordinates: c
-      };
-    }
-    function geometrycollection() {
-      const geometries = [];
-      let geometry;
-      if (!$(/^(geometrycollection)/i))
-        return null;
-      white();
-      if (!$(/^(\()/))
-        return null;
-      while (geometry = root()) {
-        geometries.push(geometry);
-        white();
-        $(/^(,)/);
-        white();
-      }
-      if (!$(/^(\))/))
-        return null;
-      return {
-        type: "GeometryCollection",
-        geometries
-      };
-    }
-    function root() {
-      return point() || linestring() || polygon() || multipoint() || multilinestring() || multipolygon() || geometrycollection();
-    }
-    return crs(root());
-  }
-  var numberRegexp, tuples;
-  var init_parse_wkt = __esm({
-    "src/lib/parse-wkt.ts"() {
-      numberRegexp = /[-+]?([0-9]*\.[0-9]+|[0-9]+)([eE][-+]?[0-9]+)?/;
-      tuples = new RegExp("^" + numberRegexp.source + "(\\s" + numberRegexp.source + "){1,}");
-    }
-  });
-
-  // src/wkt-loader.ts
-  var WKTWorkerLoader, WKTLoader;
-  var init_wkt_loader = __esm({
-    "src/wkt-loader.ts"() {
-      init_version();
-      init_parse_wkt();
-      WKTWorkerLoader = {
-        name: "WKT (Well-Known Text)",
-        id: "wkt",
-        module: "wkt",
-        version: VERSION,
-        worker: true,
-        extensions: ["wkt"],
-        mimeTypes: ["text/plain"],
-        category: "geometry",
-        text: true,
-        options: {
-          wkt: {}
-        }
-      };
-      WKTLoader = {
-        ...WKTWorkerLoader,
-        parse: async (arrayBuffer) => parseWKT(new TextDecoder().decode(arrayBuffer)),
-        parseTextSync: parseWKT
-      };
-    }
-  });
-
-  // src/lib/encode-wkt.ts
-  function encodeWKT(gj) {
-    if (gj.type === "Feature") {
-      gj = gj.geometry;
-    }
-    function pairWKT(c) {
-      return c.join(" ");
-    }
-    function ringWKT(r) {
-      return r.map(pairWKT).join(", ");
-    }
-    function ringsWKT(r) {
-      return r.map(ringWKT).map(wrapParens).join(", ");
-    }
-    function multiRingsWKT(r) {
-      return r.map(ringsWKT).map(wrapParens).join(", ");
-    }
-    function wrapParens(s) {
-      return `(${s})`;
-    }
-    switch (gj.type) {
-      case "Point":
-        return `POINT ${wrapParens(pairWKT(gj.coordinates))}`;
-      case "LineString":
-        return `LINESTRING ${wrapParens(ringWKT(gj.coordinates))}`;
-      case "Polygon":
-        return `POLYGON ${wrapParens(ringsWKT(gj.coordinates))}`;
-      case "MultiPoint":
-        return `MULTIPOINT ${wrapParens(ringWKT(gj.coordinates))}`;
-      case "MultiPolygon":
-        return `MULTIPOLYGON ${wrapParens(multiRingsWKT(gj.coordinates))}`;
-      case "MultiLineString":
-        return `MULTILINESTRING ${wrapParens(ringsWKT(gj.coordinates))}`;
-      case "GeometryCollection":
-        return `GEOMETRYCOLLECTION ${wrapParens(gj.geometries.map(encodeWKT).join(", "))}`;
-      default:
-        return ((_x) => {
-          throw new Error("stringify requires a valid GeoJSON Feature or geometry object as input");
-        })(gj);
-    }
-  }
-  var init_encode_wkt = __esm({
-    "src/lib/encode-wkt.ts"() {
-    }
-  });
-
-  // src/wkt-writer.ts
-  var WKTWriter;
-  var init_wkt_writer = __esm({
-    "src/wkt-writer.ts"() {
-      init_version();
-      init_encode_wkt();
-      WKTWriter = {
-        name: "WKT (Well Known Text)",
-        id: "wkt",
-        module: "wkt",
-        version: VERSION,
-        extensions: ["wkt"],
-        encode: encodeWKT,
-        options: {
-          wkt: {}
-        }
-      };
-    }
-  });
-
-  // src/index.ts
-  var src_exports = {};
-  __export(src_exports, {
-    WKBLoader: () => WKBLoader,
-    WKBWorkerLoader: () => WKBWorkerLoader,
-    WKTLoader: () => WKTLoader,
-    WKTWorkerLoader: () => WKTWorkerLoader,
-    WKTWriter: () => WKTWriter
-  });
-  var init_src = __esm({
-    "src/index.ts"() {
-      init_wkb_loader();
-      init_wkt_loader();
-      init_wkt_writer();
-    }
-  });
-
-  // src/bundle.ts
-  var require_bundle = __commonJS({
-    "src/bundle.ts"(exports, module) {
-      var moduleExports = (init_src(), src_exports);
-      globalThis.loaders = globalThis.loaders || {};
-      module.exports = Object.assign(globalThis.loaders, moduleExports);
-    }
-  });
-  require_bundle();
-})();
+"use strict";
+// @ts-nocheck
+const moduleExports = require('./index');
+globalThis.loaders = globalThis.loaders || {};
+module.exports = Object.assign(globalThis.loaders, moduleExports);