@loaders.gl/pointclouds 5.0.0-beta.1 → 5.0.0-beta.10

package/dist/laz-rs-loader.js

@@ -0,0 +1,2 @@
+export * from './las/laz-rs-loader.js';
+//# sourceMappingURL=laz-rs-loader.js.map

package/dist/laz-rs-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"laz-rs-loader.js","sourceRoot":"","sources":["../src/laz-rs-loader.ts"],"names":[],"mappings":"AAAA,cAAc,wBAAwB,CAAC"}

package/dist/lazperf-loader-types.cjs

@@ -0,0 +1,51 @@
+"use strict";
+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(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/lazperf-loader-types.ts
+var lazperf_loader_types_exports = {};
+__export(lazperf_loader_types_exports, {
+  LAZPerfLoader: () => LAZPerfLoader
+});
+module.exports = __toCommonJS(lazperf_loader_types_exports);
+
+// src/las/lazperf-loader-types.ts
+var import_las_loader_shared = require("./las-loader-shared.cjs");
+var LAZPerfLoader = {
+  ...import_las_loader_shared.LAS_LOADER_METADATA,
+  name: "LAS (laz-perf)",
+  preload: async () => {
+    const { LAZPerfLoaderWithParser } = await import("@loaders.gl/pointclouds/lazperf-loader");
+    return LAZPerfLoaderWithParser;
+  }
+};
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LAZPerfLoader
+});
+//# sourceMappingURL=lazperf-loader-types.cjs.map

package/dist/lazperf-loader-types.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/lazperf-loader-types.ts", "../src/las/lazperf-loader-types.ts"],
+  "sourcesContent": ["export * from './las/lazperf-loader-types.js';\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\n// LASER (LAS) FILE FORMAT\nimport type {Loader} from '@loaders.gl/core/loader-utils';\nimport type {Table, RecordBatch} from 'apache-arrow';\nimport {LAS_LOADER_METADATA, type LASLoaderOptions} from './las-loader-shared';\nimport type {LASMesh} from './lib/las-types';\n\n/**\n * Metadata-only loader for the LAS (LASer) point cloud format.\n * @note Does not support LAS v1.4\n */\nexport const LAZPerfLoader = {\n  ...LAS_LOADER_METADATA,\n  name: 'LAS (laz-perf)',\n  preload: async () => {\n    const {LAZPerfLoaderWithParser} = await import('@loaders.gl/pointclouds/lazperf-loader');\n    return LAZPerfLoaderWithParser;\n  }\n} as const satisfies Loader<LASMesh | Table, LASMesh | RecordBatch, LASLoaderOptions>;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACOA,+BAAyD;AAOlD,IAAM,gBAAgB;AAAA,EAC3B,GAAG;AAAA,EACH,MAAM;AAAA,EACN,SAAS,YAAY;AACnB,UAAM,EAAC,wBAAuB,IAAI,MAAM,OAAO,wCAAwC;AACvF,WAAO;AAAA,EACT;AACF;",
+  "names": []
+}

package/dist/lazperf-loader-types.d.ts

@@ -0,0 +1,2 @@
+export * from './las/lazperf-loader-types.js';
+//# sourceMappingURL=lazperf-loader-types.d.ts.map

package/dist/lazperf-loader-types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazperf-loader-types.d.ts","sourceRoot":"","sources":["../src/lazperf-loader-types.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC"}

package/dist/lazperf-loader-types.js

@@ -0,0 +1,2 @@
+export * from './las/lazperf-loader-types.js';
+//# sourceMappingURL=lazperf-loader-types.js.map

package/dist/lazperf-loader-types.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazperf-loader-types.js","sourceRoot":"","sources":["../src/lazperf-loader-types.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC"}

package/dist/lazperf-loader.cjs

@@ -0,0 +1,65 @@
+"use strict";
+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/lazperf-loader.ts
+var lazperf_loader_exports = {};
+__export(lazperf_loader_exports, {
+  LAZPerfLoaderWithParser: () => LAZPerfLoaderWithParser
+});
+module.exports = __toCommonJS(lazperf_loader_exports);
+
+// src/las/lazperf-loader.ts
+var import_las_loader = require("./las-loader.cjs");
+var import_schema_utils = require("@loaders.gl/core/schema-utils");
+var import_las_loader_shared = require("./las-loader-shared.cjs");
+var import_parse_las = require("./lib/laz-perf/parse-las.cjs");
+var LAZPerfLoaderWithParser = {
+  ...import_las_loader_shared.LAS_LOADER_METADATA,
+  name: "LAS (laz-perf)",
+  parse: async (arrayBuffer, options) => (0, import_las_loader.toPublicLASResult)(convertLASMesh((0, import_parse_las.parseLAS)(arrayBuffer, options), options)),
+  parseSync: (arrayBuffer, options) => (0, import_las_loader.toPublicLASResult)(convertLASMesh((0, import_parse_las.parseLAS)(arrayBuffer, options), options)),
+  parseInBatches: async function* (arrayBufferIterator, options) {
+    yield* convertLASMeshBatches((0, import_parse_las.parseLASInBatches)(arrayBufferIterator, options), options);
+  }
+};
+function convertLASMesh(mesh, options) {
+  const formattedMesh = (0, import_las_loader_shared.formatLASMeshColors)(mesh, options?.las?.colorFormat || "uint8norm");
+  const table = (0, import_schema_utils.convertMeshToArrowTableWrapper)(formattedMesh);
+  if ((0, import_las_loader_shared.getLASShape)(options) === "arrow") {
+    return { ...table, loaderData: mesh.loaderData };
+  }
+  return {
+    ...(0, import_schema_utils.convertTableToMesh)(table),
+    loader: mesh.loader,
+    loaderData: mesh.loaderData,
+    progress: mesh.progress
+  };
+}
+async function* convertLASMeshBatches(meshBatches, options) {
+  for await (const mesh of meshBatches) {
+    const result = convertLASMesh(mesh, options);
+    if ("shape" in result) yield* (0, import_las_loader.getLASRecordBatches)(result);
+    else yield result;
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  LAZPerfLoaderWithParser
+});
+//# sourceMappingURL=lazperf-loader.cjs.map

package/dist/lazperf-loader.cjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../src/lazperf-loader.ts", "../src/las/lazperf-loader.ts"],
+  "sourcesContent": ["export * from './las/lazperf-loader.js';\n", "// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\n// LASER (LAS) FILE FORMAT\nimport type {LoaderWithParser} from '@loaders.gl/core/loader-utils';\nimport type {Table, RecordBatch} from 'apache-arrow';\nimport {getLASRecordBatches, toPublicLASResult} from './las-loader';\nimport type {MeshArrowTable} from '@loaders.gl/core/schema';\nimport {convertMeshToArrowTableWrapper, convertTableToMesh} from '@loaders.gl/core/schema-utils';\nimport {\n  formatLASMeshColors,\n  getLASShape,\n  LAS_LOADER_METADATA,\n  type LASLoaderOptions\n} from './las-loader-shared';\nimport type {LASMesh} from './lib/las-types';\nimport {parseLAS, parseLASInBatches} from './lib/laz-perf/parse-las';\n\n/**\n * Loader for the LAS (LASer) point cloud format\n * @note Does not support LAS v1.4\n */\nexport const LAZPerfLoaderWithParser = {\n  ...LAS_LOADER_METADATA,\n  name: 'LAS (laz-perf)',\n  parse: async (arrayBuffer: ArrayBuffer, options?: LASLoaderOptions) =>\n    toPublicLASResult(convertLASMesh(parseLAS(arrayBuffer, options), options)),\n  parseSync: (arrayBuffer: ArrayBuffer, options?: LASLoaderOptions) =>\n    toPublicLASResult(convertLASMesh(parseLAS(arrayBuffer, options), options)),\n  parseInBatches: async function* (arrayBufferIterator, options?: LASLoaderOptions) {\n    yield* convertLASMeshBatches(parseLASInBatches(arrayBufferIterator, options), options);\n  }\n} as const satisfies LoaderWithParser<LASMesh | Table, LASMesh | RecordBatch, LASLoaderOptions>;\n\nfunction convertLASMesh(mesh: LASMesh, options?: LASLoaderOptions): LASMesh | MeshArrowTable {\n  const formattedMesh = formatLASMeshColors(mesh, options?.las?.colorFormat || 'uint8norm');\n  const table = convertMeshToArrowTableWrapper(formattedMesh) as MeshArrowTable;\n  if (getLASShape(options) === 'arrow') {\n    return {...table, loaderData: mesh.loaderData};\n  }\n  return {\n    ...(convertTableToMesh(table) as LASMesh),\n    loader: mesh.loader,\n    loaderData: mesh.loaderData,\n    progress: (mesh as LASMesh & {progress?: number}).progress\n  } as LASMesh & {progress?: number};\n}\n\n/**\n * Convert LAS mesh batches to the requested output shape.\n * @param meshBatches Decoded LAS mesh batches\n * @param options LAS loader options\n * @returns Converted LAS batches\n */\nasync function* convertLASMeshBatches(\n  meshBatches: AsyncIterable<LASMesh>,\n  options?: LASLoaderOptions\n): AsyncIterable<LASMesh | RecordBatch> {\n  for await (const mesh of meshBatches) {\n    const result = convertLASMesh(mesh, options);\n    if ('shape' in result) yield* getLASRecordBatches(result);\n    else yield result;\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;;;ACOA,wBAAqD;AAErD,0BAAiE;AACjE,+BAKO;AAEP,uBAA0C;AAMnC,IAAM,0BAA0B;AAAA,EACrC,GAAG;AAAA,EACH,MAAM;AAAA,EACN,OAAO,OAAO,aAA0B,gBACtC,qCAAkB,mBAAe,2BAAS,aAAa,OAAO,GAAG,OAAO,CAAC;AAAA,EAC3E,WAAW,CAAC,aAA0B,gBACpC,qCAAkB,mBAAe,2BAAS,aAAa,OAAO,GAAG,OAAO,CAAC;AAAA,EAC3E,gBAAgB,iBAAiB,qBAAqB,SAA4B;AAChF,WAAO,0BAAsB,oCAAkB,qBAAqB,OAAO,GAAG,OAAO;AAAA,EACvF;AACF;AAEA,SAAS,eAAe,MAAe,SAAsD;AAC3F,QAAM,oBAAgB,8CAAoB,MAAM,SAAS,KAAK,eAAe,WAAW;AACxF,QAAM,YAAQ,oDAA+B,aAAa;AAC1D,UAAI,sCAAY,OAAO,MAAM,SAAS;AACpC,WAAO,EAAC,GAAG,OAAO,YAAY,KAAK,WAAU;AAAA,EAC/C;AACA,SAAO;AAAA,IACL,OAAI,wCAAmB,KAAK;AAAA,IAC5B,QAAQ,KAAK;AAAA,IACb,YAAY,KAAK;AAAA,IACjB,UAAW,KAAuC;AAAA,EACpD;AACF;AAQA,gBAAgB,sBACd,aACA,SACsC;AACtC,mBAAiB,QAAQ,aAAa;AACpC,UAAM,SAAS,eAAe,MAAM,OAAO;AAC3C,QAAI,WAAW,OAAQ,YAAO,uCAAoB,MAAM;AAAA,QACnD,OAAM;AAAA,EACb;AACF;",
+  "names": []
+}

package/dist/lazperf-loader.d.ts

@@ -0,0 +1,2 @@
+export * from './las/lazperf-loader.js';
+//# sourceMappingURL=lazperf-loader.d.ts.map

package/dist/lazperf-loader.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazperf-loader.d.ts","sourceRoot":"","sources":["../src/lazperf-loader.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC"}

package/dist/lazperf-loader.js

@@ -0,0 +1,2 @@
+export * from './las/lazperf-loader.js';
+//# sourceMappingURL=lazperf-loader.js.map

package/dist/lazperf-loader.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lazperf-loader.js","sourceRoot":"","sources":["../src/lazperf-loader.ts"],"names":[],"mappings":"AAAA,cAAc,yBAAyB,CAAC"}

package/dist/pcd/bundled.cjs

@@ -20,14 +20,12 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/pcd/bundled.ts
 var bundled_exports = {};
 __export(bundled_exports, {
-  PCDLoader: () => import_pcd_loader.PCDLoaderWithParser,
-  PCDWorkerLoader: () => import_pcd_loader.PCDLoaderWithParser
+  PCDLoader: () => import_pcd_loader.PCDLoaderWithParser
 });
 module.exports = __toCommonJS(bundled_exports);
 var import_pcd_loader = require("./pcd-loader.cjs");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  PCDLoader,
-  PCDWorkerLoader
+  PCDLoader
 });
 //# sourceMappingURL=bundled.cjs.map

package/dist/pcd/bundled.cjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/pcd/bundled.ts"],
-  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright vis.gl contributors\n\nexport type {PCDLoaderOptions} from './pcd-loader-types';\nexport {\n  PCDLoaderWithParser as PCDWorkerLoader,\n  PCDLoaderWithParser as PCDLoader\n} from './pcd-loader';\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,wBAGO;",
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright vis.gl contributors\n\nexport type {PCDLoaderOptions} from './pcd-loader-types';\nexport {PCDLoaderWithParser as PCDLoader} from './pcd-loader';\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,wBAA+C;",
   "names": []
 }

package/dist/pcd/bundled.d.ts

@@ -1,3 +1,3 @@
 export type { PCDLoaderOptions } from "./pcd-loader-types.js";
-export { PCDLoaderWithParser as PCDWorkerLoader, PCDLoaderWithParser as PCDLoader } from "./pcd-loader.js";
+export { PCDLoaderWithParser as PCDLoader } from "./pcd-loader.js";
 //# sourceMappingURL=bundled.d.ts.map

package/dist/pcd/bundled.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"bundled.d.ts","sourceRoot":"","sources":["../../src/pcd/bundled.ts"],"names":[],"mappings":"AAIA,YAAY,EAAC,gBAAgB,EAAC,8BAA2B;AACzD,OAAO,EACL,mBAAmB,IAAI,eAAe,EACtC,mBAAmB,IAAI,SAAS,EACjC,wBAAqB"}
+{"version":3,"file":"bundled.d.ts","sourceRoot":"","sources":["../../src/pcd/bundled.ts"],"names":[],"mappings":"AAIA,YAAY,EAAC,gBAAgB,EAAC,8BAA2B;AACzD,OAAO,EAAC,mBAAmB,IAAI,SAAS,EAAC,wBAAqB"}

package/dist/pcd/bundled.js

@@ -1,5 +1,5 @@
 // loaders.gl
 // SPDX-License-Identifier: MIT
 // Copyright vis.gl contributors
-export { PCDLoaderWithParser as PCDWorkerLoader, PCDLoaderWithParser as PCDLoader } from "./pcd-loader.js";
+export { PCDLoaderWithParser as PCDLoader } from "./pcd-loader.js";
 //# sourceMappingURL=bundled.js.map

package/dist/pcd/bundled.js.map

@@ -1 +1 @@
-{"version":3,"file":"bundled.js","sourceRoot":"","sources":["../../src/pcd/bundled.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,gCAAgC;AAGhC,OAAO,EACL,mBAAmB,IAAI,eAAe,EACtC,mBAAmB,IAAI,SAAS,EACjC,wBAAqB"}
+{"version":3,"file":"bundled.js","sourceRoot":"","sources":["../../src/pcd/bundled.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,gCAAgC;AAGhC,OAAO,EAAC,mBAAmB,IAAI,SAAS,EAAC,wBAAqB"}

package/dist/pcd/index.cjs

@@ -22,19 +22,16 @@ var pcd_exports = {};
 __export(pcd_exports, {
   PCDFormat: () => import_pcd_format.PCDFormat,
   PCDLoader: () => import_pcd_loader_types.PCDLoader,
-  PCDWorkerLoader: () => import_pcd_loader_types2.PCDWorkerLoader,
   PCDWriter: () => import_pcd_writer.PCDWriter
 });
 module.exports = __toCommonJS(pcd_exports);
 var import_pcd_format = require("./pcd-format.cjs");
 var import_pcd_loader_types = require("./pcd-loader-types.cjs");
 var import_pcd_writer = require("./pcd-writer.cjs");
-var import_pcd_loader_types2 = require("./pcd-loader-types.cjs");
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
   PCDFormat,
   PCDLoader,
-  PCDWorkerLoader,
   PCDWriter
 });
 //# sourceMappingURL=index.cjs.map

package/dist/pcd/index.cjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/pcd/index.ts"],
-  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright vis.gl contributors\n\nexport type {PCDLoaderOptions} from './pcd-loader-types';\nexport {PCDFormat} from './pcd-format';\nexport {PCDLoader} from './pcd-loader-types';\nexport type {PCDWriterOptions} from './pcd-writer';\nexport {PCDWriter} from './pcd-writer';\n\n// DEPRECATED EXPORTS\n/** @deprecated Use PCDLoader. */\nexport {PCDWorkerLoader} from './pcd-loader-types';\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,wBAAwB;AACxB,8BAAwB;AAExB,wBAAwB;AAIxB,IAAAA,2BAA8B;",
-  "names": ["import_pcd_loader_types"]
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright vis.gl contributors\n\nexport type {PCDLoaderOptions} from './pcd-loader-types';\nexport {PCDFormat} from './pcd-format';\nexport {PCDLoader} from './pcd-loader-types';\nexport type {PCDWriterOptions} from './pcd-writer';\nexport {PCDWriter} from './pcd-writer';\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAKA,wBAAwB;AACxB,8BAAwB;AAExB,wBAAwB;",
+  "names": []
 }

package/dist/pcd/index.d.ts

@@ -3,6 +3,4 @@ export { PCDFormat } from "./pcd-format.js";
 export { PCDLoader } from "./pcd-loader-types.js";
 export type { PCDWriterOptions } from "./pcd-writer.js";
 export { PCDWriter } from "./pcd-writer.js";
-/** @deprecated Use PCDLoader. */
-export { PCDWorkerLoader } from "./pcd-loader-types.js";
 //# sourceMappingURL=index.d.ts.map

package/dist/pcd/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/pcd/index.ts"],"names":[],"mappings":"AAIA,YAAY,EAAC,gBAAgB,EAAC,8BAA2B;AACzD,OAAO,EAAC,SAAS,EAAC,wBAAqB;AACvC,OAAO,EAAC,SAAS,EAAC,8BAA2B;AAC7C,YAAY,EAAC,gBAAgB,EAAC,wBAAqB;AACnD,OAAO,EAAC,SAAS,EAAC,wBAAqB;AAGvC,iCAAiC;AACjC,OAAO,EAAC,eAAe,EAAC,8BAA2B"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/pcd/index.ts"],"names":[],"mappings":"AAIA,YAAY,EAAC,gBAAgB,EAAC,8BAA2B;AACzD,OAAO,EAAC,SAAS,EAAC,wBAAqB;AACvC,OAAO,EAAC,SAAS,EAAC,8BAA2B;AAC7C,YAAY,EAAC,gBAAgB,EAAC,wBAAqB;AACnD,OAAO,EAAC,SAAS,EAAC,wBAAqB"}

package/dist/pcd/index.js

@@ -4,7 +4,4 @@
 export { PCDFormat } from "./pcd-format.js";
 export { PCDLoader } from "./pcd-loader-types.js";
 export { PCDWriter } from "./pcd-writer.js";
-// DEPRECATED EXPORTS
-/** @deprecated Use PCDLoader. */
-export { PCDWorkerLoader } from "./pcd-loader-types.js";
 //# sourceMappingURL=index.js.map

package/dist/pcd/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/pcd/index.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,gCAAgC;AAGhC,OAAO,EAAC,SAAS,EAAC,wBAAqB;AACvC,OAAO,EAAC,SAAS,EAAC,8BAA2B;AAE7C,OAAO,EAAC,SAAS,EAAC,wBAAqB;AAEvC,qBAAqB;AACrB,iCAAiC;AACjC,OAAO,EAAC,eAAe,EAAC,8BAA2B"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../src/pcd/index.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,gCAAgC;AAGhC,OAAO,EAAC,SAAS,EAAC,wBAAqB;AACvC,OAAO,EAAC,SAAS,EAAC,8BAA2B;AAE7C,OAAO,EAAC,SAAS,EAAC,wBAAqB"}

package/dist/pcd/pcd-loader-types.cjs

@@ -30,18 +30,19 @@ var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: tru
 // src/pcd/pcd-loader-types.ts
 var pcd_loader_types_exports = {};
 __export(pcd_loader_types_exports, {
-  PCDLoader: () => PCDLoader,
-  PCDWorkerLoader: () => PCDWorkerLoader
+  PCDLoader: () => PCDLoader
 });
 module.exports = __toCommonJS(pcd_loader_types_exports);
 var import_pcd_format = require("./pcd-format.cjs");
-var import_arrow_transport = require("@loaders.gl/core/schema-utils/arrow-transport");
-var VERSION = true ? "5.0.0-beta.1" : "latest";
+var import_arrow_worker_transport = require("@loaders.gl/core/arrow-worker-transport");
+var VERSION = true ? "5.0.0-beta.10" : "latest";
 async function preload() {
-  const { PCDLoaderWithParser } = await import("@loaders.gl/pointclouds/pcd/pcd-loader");
+  const { PCDLoaderWithParser } = await import("@loaders.gl/pointclouds/pcd-loader");
   return PCDLoaderWithParser;
 }
 var PCDLoader = {
+  defaultShape: "arrow",
+  supportsNativeArrow: true,
   ...import_pcd_format.PCDFormat,
   dataType: null,
   batchType: null,
@@ -49,16 +50,14 @@ var PCDLoader = {
   worker: true,
   /** Enables the stateful input/output batch protocol on the built-in worker. */
   workerInBatches: true,
-  serializeWorkerResult: import_arrow_transport.serializeArrowWorkerTable,
+  serializeWorkerResult: import_arrow_worker_transport.serializeArrowWorkerTable,
   options: {
-    pcd: { shape: "arrow-table", colorFormat: "uint8norm" }
+    pcd: { shape: "arrow", colorFormat: "uint8norm" }
   },
   preload
 };
-var PCDWorkerLoader = PCDLoader;
 // Annotate the CommonJS export names for ESM import in node:
 0 && (module.exports = {
-  PCDLoader,
-  PCDWorkerLoader
+  PCDLoader
 });
 //# sourceMappingURL=pcd-loader-types.cjs.map

package/dist/pcd/pcd-loader-types.cjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/pcd/pcd-loader-types.ts"],
-  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {Loader, LoaderOptions} from '@loaders.gl/core/loader-utils';\nimport type {MeshArrowTable, ArrowTableBatch} from '@loaders.gl/core/schema';\nimport type {PCDMesh} from './lib/pcd-types';\nimport {PCDFormat} from './pcd-format';\nimport {serializeArrowWorkerTable} from '@loaders.gl/core/schema-utils/arrow-transport';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\nexport type PCDLoaderOptions = LoaderOptions & {\n  pcd?: {\n    /** Output shape. Defaults to a Mesh Arrow table. */\n    shape?: 'mesh' | 'arrow-table';\n    /** Color storage format. Defaults to uint8norm for backwards compatibility. */\n    colorFormat?: 'uint8norm' | 'float16' | 'float32';\n    /** Override the URL to the worker bundle (by default loads from unpkg.com) */\n    workerUrl?: string;\n  };\n};\n\n/**\n * Preloads the parser-bearing PCD loader implementation.\n */\nasync function preload() {\n  const {PCDLoaderWithParser} = await import('@loaders.gl/pointclouds/pcd/pcd-loader');\n  return PCDLoaderWithParser;\n}\n\n/**\n * Metadata-only worker loader for PCD - Point Cloud Data\n */\nexport const PCDLoader = {\n  ...PCDFormat,\n  dataType: null as unknown as PCDMesh | MeshArrowTable,\n  batchType: null as unknown as PCDMesh | ArrowTableBatch,\n  version: VERSION,\n  worker: true,\n  /** Enables the stateful input/output batch protocol on the built-in worker. */\n  workerInBatches: true,\n  serializeWorkerResult: serializeArrowWorkerTable,\n  options: {\n    pcd: {shape: 'arrow-table', colorFormat: 'uint8norm'}\n  },\n  preload\n} as const satisfies Loader<PCDMesh | MeshArrowTable, PCDMesh | ArrowTableBatch, PCDLoaderOptions>;\n\n/** @deprecated Use PCDLoader. */\nexport const PCDWorkerLoader = PCDLoader;\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,wBAAwB;AACxB,6BAAwC;AAIxC,IAAM,UAAU,OAAqC,iBAAc;AAgBnE,eAAe,UAAU;AACvB,QAAM,EAAC,oBAAmB,IAAI,MAAM,OAAO,wCAAwC;AACnF,SAAO;AACT;AAKO,IAAM,YAAY;AAAA,EACvB,GAAG;AAAA,EACH,UAAU;AAAA,EACV,WAAW;AAAA,EACX,SAAS;AAAA,EACT,QAAQ;AAAA;AAAA,EAER,iBAAiB;AAAA,EACjB,uBAAuB;AAAA,EACvB,SAAS;AAAA,IACP,KAAK,EAAC,OAAO,eAAe,aAAa,YAAW;AAAA,EACtD;AAAA,EACA;AACF;AAGO,IAAM,kBAAkB;",
+  "sourcesContent": ["// loaders.gl\n// SPDX-License-Identifier: MIT\n// Copyright (c) vis.gl contributors\n\nimport type {Table, RecordBatch} from 'apache-arrow';\nimport type {Loader, LoaderOptions} from '@loaders.gl/core/loader-utils';\nimport type {PCDMesh} from './lib/pcd-types';\nimport {PCDFormat} from './pcd-format';\nimport {serializeArrowWorkerTable} from '@loaders.gl/core/arrow-worker-transport';\n\n// __VERSION__ is injected by babel-plugin-version-inline\n// @ts-ignore TS2304: Cannot find name '__VERSION__'.\nconst VERSION = typeof __VERSION__ !== 'undefined' ? __VERSION__ : 'latest';\n\nexport type PCDLoaderOptions = LoaderOptions & {\n  pcd?: {\n    /** Output shape. Defaults to a Mesh Arrow table. */\n    shape?: 'mesh' | 'arrow';\n    /** Color storage format. Defaults to uint8norm for backwards compatibility. */\n    colorFormat?: 'uint8norm' | 'float16' | 'float32';\n    /** Override the URL to the worker bundle (by default loads from unpkg.com) */\n    workerUrl?: string;\n  };\n};\n\n/**\n * Preloads the parser-bearing PCD loader implementation.\n */\nasync function preload() {\n  const {PCDLoaderWithParser} = await import('@loaders.gl/pointclouds/pcd-loader');\n  return PCDLoaderWithParser;\n}\n\n/**\n * Metadata-only worker loader for PCD - Point Cloud Data\n */\nexport const PCDLoader = {\n  defaultShape: 'arrow',\n  supportsNativeArrow: true,\n  ...PCDFormat,\n  dataType: null as unknown as PCDMesh | Table,\n  batchType: null as unknown as PCDMesh | RecordBatch,\n  version: VERSION,\n  worker: true,\n  /** Enables the stateful input/output batch protocol on the built-in worker. */\n  workerInBatches: true,\n  serializeWorkerResult: serializeArrowWorkerTable,\n  options: {\n    pcd: {shape: 'arrow', colorFormat: 'uint8norm'}\n  },\n  preload\n} as const satisfies Loader<PCDMesh | Table, PCDMesh | RecordBatch, PCDLoaderOptions>;\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAOA,wBAAwB;AACxB,oCAAwC;AAIxC,IAAM,UAAU,OAAqC,kBAAc;AAgBnE,eAAe,UAAU;AACvB,QAAM,EAAC,oBAAmB,IAAI,MAAM,OAAO,oCAAoC;AAC/E,SAAO;AACT;AAKO,IAAM,YAAY;AAAA,EACvB,cAAc;AAAA,EACd,qBAAqB;AAAA,EACrB,GAAG;AAAA,EACH,UAAU;AAAA,EACV,WAAW;AAAA,EACX,SAAS;AAAA,EACT,QAAQ;AAAA;AAAA,EAER,iBAAiB;AAAA,EACjB,uBAAuB;AAAA,EACvB,SAAS;AAAA,IACP,KAAK,EAAC,OAAO,SAAS,aAAa,YAAW;AAAA,EAChD;AAAA,EACA;AACF;",
   "names": []
 }

package/dist/pcd/pcd-loader-types.d.ts

@@ -1,11 +1,11 @@
+import type { Table, RecordBatch } from 'apache-arrow';
 import type { LoaderOptions } from '@loaders.gl/core/loader-utils';
-import type { MeshArrowTable, ArrowTableBatch } from '@loaders.gl/core/schema';
 import type { PCDMesh } from "./lib/pcd-types.js";
-import { serializeArrowWorkerTable } from '@loaders.gl/core/schema-utils/arrow-transport';
+import { serializeArrowWorkerTable } from '@loaders.gl/core/arrow-worker-transport';
 export type PCDLoaderOptions = LoaderOptions & {
     pcd?: {
         /** Output shape. Defaults to a Mesh Arrow table. */
-        shape?: 'mesh' | 'arrow-table';
+        shape?: 'mesh' | 'arrow';
         /** Color storage format. Defaults to uint8norm for backwards compatibility. */
         colorFormat?: 'uint8norm' | 'float16' | 'float32';
         /** Override the URL to the worker bundle (by default loads from unpkg.com) */
@@ -16,21 +16,21 @@ export type PCDLoaderOptions = LoaderOptions & {
  * Preloads the parser-bearing PCD loader implementation.
  */
 declare function preload(): Promise<{
-    readonly parse: (arrayBuffer: ArrayBuffer, options: PCDLoaderOptions | undefined) => Promise<MeshArrowTable | PCDMesh>;
-    readonly parseSync: (arrayBuffer: ArrayBuffer, options: PCDLoaderOptions | undefined) => MeshArrowTable | PCDMesh;
-    readonly parseInBatches: (arrayBuffer: AsyncIterable<ArrayBufferLike | ArrayBufferView> | Iterable<ArrayBufferLike | ArrayBufferView>, options: PCDLoaderOptions | undefined) => AsyncIterable<PCDMesh | ArrowTableBatch>;
+    readonly dataType: Table<any> | PCDMesh;
+    readonly batchType: RecordBatch<any> | PCDMesh;
+    readonly parse: (input: ArrayBuffer, options?: PCDLoaderOptions) => Promise<Table<any> | PCDMesh>;
+    readonly parseSync: (input: ArrayBuffer, options?: PCDLoaderOptions) => Table<any> | PCDMesh;
+    readonly parseInBatches: (input: AsyncIterable<ArrayBufferLike | ArrayBufferView<ArrayBufferLike>> | Iterable<ArrayBufferLike | ArrayBufferView<ArrayBufferLike>>, options: PCDLoaderOptions | undefined) => AsyncGenerator<RecordBatch<any> | PCDMesh, void, unknown>;
+    readonly deserializeWorkerResult: (result: unknown, options?: PCDLoaderOptions) => Table<any> | PCDMesh;
+    readonly deserializeWorkerBatch: (result: unknown, options?: PCDLoaderOptions) => RecordBatch<any> | PCDMesh;
     readonly serializeWorkerResult: typeof serializeArrowWorkerTable;
-    readonly deserializeWorkerResult: (result: unknown, options?: PCDLoaderOptions) => PCDMesh | MeshArrowTable;
     readonly serializeWorkerBatch: typeof serializeArrowWorkerTable;
-    readonly deserializeWorkerBatch: (result: unknown, options?: PCDLoaderOptions) => PCDMesh | ArrowTableBatch;
-    readonly dataType: PCDMesh | MeshArrowTable;
-    readonly batchType: PCDMesh | ArrowTableBatch;
     readonly version: any;
     readonly worker: true;
     readonly workerInBatches: true;
     readonly options: {
         readonly pcd: {
-            readonly shape: "arrow-table";
+            readonly shape: "arrow";
             readonly colorFormat: "uint8norm";
         };
     };
@@ -44,13 +44,15 @@ declare function preload(): Promise<{
     readonly category: "pointcloud";
     readonly text: true;
     readonly binary: true;
+    readonly defaultShape: "arrow";
+    readonly supportsNativeArrow: true;
 }>;
 /**
  * Metadata-only worker loader for PCD - Point Cloud Data
  */
 export declare const PCDLoader: {
-    readonly dataType: PCDMesh | MeshArrowTable;
-    readonly batchType: PCDMesh | ArrowTableBatch;
+    readonly dataType: PCDMesh | Table;
+    readonly batchType: PCDMesh | RecordBatch;
     readonly version: any;
     readonly worker: true;
     /** Enables the stateful input/output batch protocol on the built-in worker. */
@@ -58,34 +60,7 @@ export declare const PCDLoader: {
     readonly serializeWorkerResult: typeof serializeArrowWorkerTable;
     readonly options: {
         readonly pcd: {
-            readonly shape: "arrow-table";
-            readonly colorFormat: "uint8norm";
-        };
-    };
-    readonly preload: typeof preload;
-    readonly name: "PCD (Point Cloud Data)";
-    readonly id: "pcd";
-    readonly module: "pointclouds";
-    readonly encoding: "text";
-    readonly format: "pcd";
-    readonly extensions: ["pcd"];
-    readonly mimeTypes: ["text/plain"];
-    readonly category: "pointcloud";
-    readonly text: true;
-    readonly binary: true;
-};
-/** @deprecated Use PCDLoader. */
-export declare const PCDWorkerLoader: {
-    readonly dataType: PCDMesh | MeshArrowTable;
-    readonly batchType: PCDMesh | ArrowTableBatch;
-    readonly version: any;
-    readonly worker: true;
-    /** Enables the stateful input/output batch protocol on the built-in worker. */
-    readonly workerInBatches: true;
-    readonly serializeWorkerResult: typeof serializeArrowWorkerTable;
-    readonly options: {
-        readonly pcd: {
-            readonly shape: "arrow-table";
+            readonly shape: "arrow";
             readonly colorFormat: "uint8norm";
         };
     };
@@ -100,6 +75,8 @@ export declare const PCDWorkerLoader: {
     readonly category: "pointcloud";
     readonly text: true;
     readonly binary: true;
+    readonly defaultShape: "arrow";
+    readonly supportsNativeArrow: true;
 };
 export {};
 //# sourceMappingURL=pcd-loader-types.d.ts.map

package/dist/pcd/pcd-loader-types.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pcd-loader-types.d.ts","sourceRoot":"","sources":["../../src/pcd/pcd-loader-types.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAS,aAAa,EAAC,MAAM,+BAA+B,CAAC;AACzE,OAAO,KAAK,EAAC,cAAc,EAAE,eAAe,EAAC,MAAM,yBAAyB,CAAC;AAC7E,OAAO,KAAK,EAAC,OAAO,EAAC,2BAAwB;AAE7C,OAAO,EAAC,yBAAyB,EAAC,MAAM,+CAA+C,CAAC;AAMxF,MAAM,MAAM,gBAAgB,GAAG,aAAa,GAAG;IAC7C,GAAG,CAAC,EAAE;QACJ,oDAAoD;QACpD,KAAK,CAAC,EAAE,MAAM,GAAG,aAAa,CAAC;QAC/B,+EAA+E;QAC/E,WAAW,CAAC,EAAE,WAAW,GAAG,SAAS,GAAG,SAAS,CAAC;QAClD,8EAA8E;QAC9E,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;CACH,CAAC;AAEF;;GAEG;AACH,iBAAe,OAAO;;;;;;;;uBAUS,OAAO,GAAG,cAAc;wBACvB,OAAO,GAAG,eAAe;;;;;;;;;;;;;;;;;;;;GARxD;AAED;;GAEG;AACH,eAAO,MAAM,SAAS;uBAES,OAAO,GAAG,cAAc;wBACvB,OAAO,GAAG,eAAe;;;IAGvD,+EAA+E;;;;;;;;;;;;;;;;;;;;CAOiB,CAAC;AAEnG,iCAAiC;AACjC,eAAO,MAAM,eAAe;uBAdG,OAAO,GAAG,cAAc;wBACvB,OAAO,GAAG,eAAe;;;IAGvD,+EAA+E;;;;;;;;;;;;;;;;;;;;CAUzC,CAAC"}
+{"version":3,"file":"pcd-loader-types.d.ts","sourceRoot":"","sources":["../../src/pcd/pcd-loader-types.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,EAAC,KAAK,EAAE,WAAW,EAAC,MAAM,cAAc,CAAC;AACrD,OAAO,KAAK,EAAS,aAAa,EAAC,MAAM,+BAA+B,CAAC;AACzE,OAAO,KAAK,EAAC,OAAO,EAAC,2BAAwB;AAE7C,OAAO,EAAC,yBAAyB,EAAC,MAAM,yCAAyC,CAAC;AAMlF,MAAM,MAAM,gBAAgB,GAAG,aAAa,GAAG;IAC7C,GAAG,CAAC,EAAE;QACJ,oDAAoD;QACpD,KAAK,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC;QACzB,+EAA+E;QAC/E,WAAW,CAAC,EAAE,WAAW,GAAG,SAAS,GAAG,SAAS,CAAC;QAClD,8EAA8E;QAC9E,SAAS,CAAC,EAAE,MAAM,CAAC;KACpB,CAAC;CACH,CAAC;AAEF;;GAEG;AACH,iBAAe,OAAO;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAGrB;AAED;;GAEG;AACH,eAAO,MAAM,SAAS;uBAIS,OAAO,GAAG,KAAK;wBACd,OAAO,GAAG,WAAW;;;IAGnD,+EAA+E;;;;;;;;;;;;;;;;;;;;;;CAOI,CAAC"}

package/dist/pcd/pcd-loader-types.js

@@ -2,21 +2,23 @@
 // SPDX-License-Identifier: MIT
 // Copyright (c) vis.gl contributors
 import { PCDFormat } from "./pcd-format.js";
-import { serializeArrowWorkerTable } from '@loaders.gl/core/schema-utils/arrow-transport';
+import { serializeArrowWorkerTable } from '@loaders.gl/core/arrow-worker-transport';
 // __VERSION__ is injected by babel-plugin-version-inline
 // @ts-ignore TS2304: Cannot find name '__VERSION__'.
-const VERSION = typeof "5.0.0-beta.1" !== 'undefined' ? "5.0.0-beta.1" : 'latest';
+const VERSION = typeof "5.0.0-beta.10" !== 'undefined' ? "5.0.0-beta.10" : 'latest';
 /**
  * Preloads the parser-bearing PCD loader implementation.
  */
 async function preload() {
-    const { PCDLoaderWithParser } = await import('@loaders.gl/pointclouds/pcd/pcd-loader');
+    const { PCDLoaderWithParser } = await import('@loaders.gl/pointclouds/pcd-loader');
     return PCDLoaderWithParser;
 }
 /**
  * Metadata-only worker loader for PCD - Point Cloud Data
  */
 export const PCDLoader = {
+    defaultShape: 'arrow',
+    supportsNativeArrow: true,
     ...PCDFormat,
     dataType: null,
     batchType: null,
@@ -26,10 +28,8 @@ export const PCDLoader = {
     workerInBatches: true,
     serializeWorkerResult: serializeArrowWorkerTable,
     options: {
-        pcd: { shape: 'arrow-table', colorFormat: 'uint8norm' }
+        pcd: { shape: 'arrow', colorFormat: 'uint8norm' }
     },
     preload
 };
-/** @deprecated Use PCDLoader. */
-export const PCDWorkerLoader = PCDLoader;
 //# sourceMappingURL=pcd-loader-types.js.map

package/dist/pcd/pcd-loader-types.js.map

@@ -1 +1 @@
-{"version":3,"file":"pcd-loader-types.js","sourceRoot":"","sources":["../../src/pcd/pcd-loader-types.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAKpC,OAAO,EAAC,SAAS,EAAC,wBAAqB;AACvC,OAAO,EAAC,yBAAyB,EAAC,MAAM,+CAA+C,CAAC;AAExF,yDAAyD;AACzD,qDAAqD;AACrD,MAAM,OAAO,GAAG,qBAAkB,KAAK,WAAW,CAAC,CAAC,gBAAa,CAAC,CAAC,QAAQ,CAAC;AAa5E;;GAEG;AACH,KAAK,UAAU,OAAO;IACpB,MAAM,EAAC,mBAAmB,EAAC,GAAG,MAAM,MAAM,CAAC,wCAAwC,CAAC,CAAC;IACrF,OAAO,mBAAmB,CAAC;AAC7B,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,GAAG,SAAS;IACZ,QAAQ,EAAE,IAA2C;IACrD,SAAS,EAAE,IAA4C;IACvD,OAAO,EAAE,OAAO;IAChB,MAAM,EAAE,IAAI;IACZ,+EAA+E;IAC/E,eAAe,EAAE,IAAI;IACrB,qBAAqB,EAAE,yBAAyB;IAChD,OAAO,EAAE;QACP,GAAG,EAAE,EAAC,KAAK,EAAE,aAAa,EAAE,WAAW,EAAE,WAAW,EAAC;KACtD;IACD,OAAO;CACyF,CAAC;AAEnG,iCAAiC;AACjC,MAAM,CAAC,MAAM,eAAe,GAAG,SAAS,CAAC"}
+{"version":3,"file":"pcd-loader-types.js","sourceRoot":"","sources":["../../src/pcd/pcd-loader-types.ts"],"names":[],"mappings":"AAAA,aAAa;AACb,+BAA+B;AAC/B,oCAAoC;AAKpC,OAAO,EAAC,SAAS,EAAC,wBAAqB;AACvC,OAAO,EAAC,yBAAyB,EAAC,MAAM,yCAAyC,CAAC;AAElF,yDAAyD;AACzD,qDAAqD;AACrD,MAAM,OAAO,GAAG,sBAAkB,KAAK,WAAW,CAAC,CAAC,iBAAa,CAAC,CAAC,QAAQ,CAAC;AAa5E;;GAEG;AACH,KAAK,UAAU,OAAO;IACpB,MAAM,EAAC,mBAAmB,EAAC,GAAG,MAAM,MAAM,CAAC,oCAAoC,CAAC,CAAC;IACjF,OAAO,mBAAmB,CAAC;AAC7B,CAAC;AAED;;GAEG;AACH,MAAM,CAAC,MAAM,SAAS,GAAG;IACvB,YAAY,EAAE,OAAO;IACrB,mBAAmB,EAAE,IAAI;IACzB,GAAG,SAAS;IACZ,QAAQ,EAAE,IAAkC;IAC5C,SAAS,EAAE,IAAwC;IACnD,OAAO,EAAE,OAAO;IAChB,MAAM,EAAE,IAAI;IACZ,+EAA+E;IAC/E,eAAe,EAAE,IAAI;IACrB,qBAAqB,EAAE,yBAAyB;IAChD,OAAO,EAAE;QACP,GAAG,EAAE,EAAC,KAAK,EAAE,OAAO,EAAE,WAAW,EAAE,WAAW,EAAC;KAChD;IACD,OAAO;CAC4E,CAAC"}