@walkthru-earth/objex 1.3.1 → 1.4.0

package/dist/utils/notebook.js

@@ -1,211 +0,0 @@
-/**
- * Lightweight browser-native Jupyter notebook renderer.
- * Replaces `notebookjs` which depends on jsdom/Buffer (Node.js only).
- * Handles nbformat 2, 3, 4, and 5.
- */
-const PREFIX = 'nb-';
-// ── Helpers ──────────────────────────────────────────────────────────────────
-function el(tag, classNames = []) {
-    const e = document.createElement(tag);
-    if (classNames.length)
-        e.className = classNames.map((c) => PREFIX + c).join(' ');
-    return e;
-}
-function escapeHTML(raw) {
-    return raw.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;');
-}
-function joinText(text) {
-    if (Array.isArray(text))
-        return text.join('');
-    return text ?? '';
-}
-// ── Display renderers ────────────────────────────────────────────────────────
-const IMAGE_FORMATS = ['image/png', 'image/jpeg', 'image/gif', 'image/webp'];
-function renderImage(format, data) {
-    const img = el('img', ['image-output']);
-    img.src = `data:${format};base64,${joinText(data).replace(/\n/g, '')}`;
-    return img;
-}
-function renderDisplayData(output, config) {
-    // Resolve data from v4 `data` field or v3 flat fields
-    const getData = (mime) => output.data?.[mime] ?? output[mime];
-    // Priority order (richest first)
-    for (const fmt of IMAGE_FORMATS) {
-        const d = getData(fmt);
-        if (d)
-            return renderImage(fmt, d);
-    }
-    const svg = getData('image/svg+xml') ?? getData('text/svg+xml');
-    if (svg) {
-        const wrapper = el('div', ['svg-output']);
-        wrapper.innerHTML = joinText(svg);
-        return wrapper;
-    }
-    const html = getData('text/html');
-    if (html) {
-        const wrapper = el('div', ['html-output']);
-        wrapper.innerHTML = joinText(html);
-        return wrapper;
-    }
-    const md = getData('text/markdown');
-    if (md) {
-        const wrapper = el('div', ['html-output']);
-        wrapper.innerHTML = config.markdown(joinText(md));
-        return wrapper;
-    }
-    const latex = getData('text/latex');
-    if (latex) {
-        const wrapper = el('div', ['latex-output']);
-        wrapper.textContent = joinText(latex);
-        return wrapper;
-    }
-    const plain = getData('text/plain');
-    if (plain) {
-        const pre = el('pre', ['text-output']);
-        pre.innerHTML = config.ansi(escapeHTML(joinText(plain)));
-        return pre;
-    }
-    return el('div', ['empty-output']);
-}
-function renderStream(output, config) {
-    const streamName = output.stream ?? output.name ?? 'stdout';
-    const pre = el('pre', [streamName]);
-    pre.innerHTML = config.ansi(escapeHTML(joinText(output.text ?? '')));
-    return pre;
-}
-function renderError(output, config) {
-    const pre = el('pre', ['pyerr']);
-    const raw = (output.traceback ?? []).join('\n');
-    pre.innerHTML = config.ansi(escapeHTML(raw));
-    return pre;
-}
-// ── Output coalescing (merge consecutive same-name streams) ──────────────────
-function coalesceStreams(outputs) {
-    if (!outputs.length)
-        return outputs;
-    const result = [{ ...outputs[0] }];
-    for (let i = 1; i < outputs.length; i++) {
-        const o = outputs[i];
-        const last = result[result.length - 1];
-        if (o.output_type === 'stream' &&
-            last.output_type === 'stream' &&
-            (o.stream ?? o.name) === (last.stream ?? last.name)) {
-            // Merge text
-            const lastText = Array.isArray(last.text) ? last.text : [last.text ?? ''];
-            const oText = Array.isArray(o.text) ? o.text : [o.text ?? ''];
-            last.text = lastText.concat(oText);
-        }
-        else {
-            result.push({ ...o });
-        }
-    }
-    return result;
-}
-// ── Cell renderers ───────────────────────────────────────────────────────────
-function renderCodeCell(cell, lang, config) {
-    const cellEl = el('div', ['cell', 'code-cell']);
-    // Input
-    const source = joinText(cell.source ?? cell.input ?? '');
-    if (source) {
-        const holder = el('div', ['input']);
-        const num = cell.prompt_number ?? cell.execution_count;
-        if (typeof num === 'number' && num > -1) {
-            holder.setAttribute('data-prompt-number', String(num));
-        }
-        const pre = el('pre');
-        const code = document.createElement('code');
-        code.setAttribute('data-language', lang);
-        code.className = `lang-${lang}`;
-        code.innerHTML = config.highlighter(escapeHTML(source), lang);
-        pre.appendChild(code);
-        holder.appendChild(pre);
-        cellEl.appendChild(holder);
-    }
-    // Outputs
-    const rawOutputs = coalesceStreams(cell.outputs ?? []);
-    for (const output of rawOutputs) {
-        const outer = el('div', ['output']);
-        let inner;
-        switch (output.output_type) {
-            case 'display_data':
-            case 'execute_result':
-            case 'pyout':
-                inner = renderDisplayData(output, config);
-                break;
-            case 'stream':
-                inner = renderStream(output, config);
-                break;
-            case 'error':
-            case 'pyerr':
-                inner = renderError(output, config);
-                break;
-            default:
-                inner = el('div', ['empty-output']);
-        }
-        outer.appendChild(inner);
-        cellEl.appendChild(outer);
-    }
-    return cellEl;
-}
-function renderMarkdownCell(cell, config) {
-    const cellEl = el('div', ['cell', 'markdown-cell']);
-    const source = joinText(cell.source ?? cell.input ?? '');
-    cellEl.innerHTML = config.markdown(source);
-    return cellEl;
-}
-function renderHeadingCell(cell) {
-    const level = Math.min(Math.max(cell.level ?? 1, 1), 6);
-    const heading = el(`h${level}`, ['cell', 'heading-cell']);
-    heading.innerHTML = escapeHTML(joinText(cell.source ?? cell.input ?? ''));
-    return heading;
-}
-function renderRawCell(cell) {
-    const cellEl = el('div', ['cell', 'raw-cell']);
-    cellEl.innerHTML = escapeHTML(joinText(cell.source ?? cell.input ?? ''));
-    return cellEl;
-}
-/**
- * Parse and render a Jupyter notebook JSON to a DOM element.
- * Returns the rendered element and metadata.
- */
-export function renderNotebook(raw, config) {
-    const meta = raw.metadata ?? {};
-    const lang = meta.kernelspec?.language ?? meta.language_info?.name ?? meta.language ?? 'python';
-    const kernelName = meta.kernelspec?.display_name ?? meta.language_info?.name ?? '';
-    // Normalize cells: v4+ has top-level `cells`, v2/v3 uses `worksheets`
-    let allCells = [];
-    if (Array.isArray(raw.cells)) {
-        allCells = raw.cells;
-    }
-    else if (Array.isArray(raw.worksheets)) {
-        for (const ws of raw.worksheets) {
-            if (Array.isArray(ws.cells))
-                allCells.push(...ws.cells);
-        }
-    }
-    const notebook = el('div', ['notebook']);
-    for (const cell of allCells) {
-        let rendered;
-        switch (cell.cell_type) {
-            case 'code':
-                rendered = renderCodeCell(cell, cell.language ?? lang, config);
-                break;
-            case 'markdown':
-                rendered = renderMarkdownCell(cell, config);
-                break;
-            case 'heading':
-                rendered = renderHeadingCell(cell);
-                break;
-            case 'raw':
-                rendered = renderRawCell(cell);
-                break;
-            default:
-                rendered = renderRawCell(cell);
-        }
-        notebook.appendChild(rendered);
-    }
-    return {
-        element: notebook,
-        meta: { kernelName, language: lang, cellCount: allCells.length }
-    };
-}

package/dist/utils/parquet-metadata.d.ts

@@ -1,64 +0,0 @@
-/**
- * Lightweight Parquet metadata reader using hyparquet.
- *
- * Reads schema, row count, CRS, and geometry types from the Parquet footer
- * via a single HTTP range request (~512KB). No DuckDB boot needed.
- *
- * This provides instant metadata display before DuckDB-WASM finishes loading.
- */
-import type { GeoArrowGeomType } from './geoarrow.js';
-export interface GeoColumnMeta {
-    encoding: string;
-    geometryTypes: string[];
-    crs: any | null;
-    bbox?: number[];
-}
-export interface GeoParquetMeta {
-    primaryColumn: string;
-    columns: Record<string, GeoColumnMeta>;
-}
-export interface ParquetFileMetadata {
-    /** Total number of rows across all row groups. */
-    rowCount: number;
-    /** Column schema (name + type). Leaf columns only (structs flattened to children). */
-    schema: {
-        name: string;
-        type: string;
-    }[];
-    /**
-     * Top-level column names as written. Includes struct/group parents (e.g.
-     * `assets`, `bbox`) that `schema` flattens away. Required for stac-geoparquet
-     * detection, which looks up struct columns by their parent name.
-     */
-    topLevelColumns: string[];
-    /** GeoParquet "geo" metadata if present. */
-    geo: GeoParquetMeta | null;
-    /** True when file has legacy GeoParquet metadata (schema_version 0.x without "version" field). */
-    legacyGeoParquet: boolean;
-    /** Tool that created the file (e.g. "pyarrow 15.0.0"). */
-    createdBy: string | null;
-    /** Number of row groups. */
-    numRowGroups: number;
-    /** Primary compression codec (e.g. "SNAPPY", "ZSTD"). */
-    compression: string | null;
-}
-/**
- * Read Parquet footer metadata from a remote URL using hyparquet.
- * Uses HTTP range requests — typically a single ~512KB fetch.
- */
-export declare function readParquetMetadata(url: string): Promise<ParquetFileMetadata>;
-/**
- * Extract EPSG code from GeoParquet CRS metadata.
- * Returns null for WGS84/CRS84 (no reprojection needed).
- */
-export declare function extractEpsgFromGeoMeta(geo: GeoParquetMeta): string | null;
-/**
- * Extract normalized geometry types from GeoParquet metadata.
- * Returns the set of geometry types for the primary column.
- */
-export declare function extractGeometryTypes(geo: GeoParquetMeta): GeoArrowGeomType[];
-/**
- * Extract bounds from GeoParquet metadata (bbox field).
- * Returns [minX, minY, maxX, maxY] or null.
- */
-export declare function extractBounds(geo: GeoParquetMeta): [number, number, number, number] | null;

package/dist/utils/parquet-metadata.js

@@ -1,262 +0,0 @@
-/**
- * Lightweight Parquet metadata reader using hyparquet.
- *
- * Reads schema, row count, CRS, and geometry types from the Parquet footer
- * via a single HTTP range request (~512KB). No DuckDB boot needed.
- *
- * This provides instant metadata display before DuckDB-WASM finishes loading.
- */
-import { WGS84_CODES } from '../constants.js';
-/** Map hyparquet schema element types to DuckDB-like type strings. */
-function mapParquetType(col) {
-    const lt = col.logical_type;
-    if (lt) {
-        // Parquet Format 2.11+ native geometry/geography types
-        if (lt.type === 'GEOMETRY' || lt.type === 'GEOGRAPHY')
-            return 'GEOMETRY';
-        // String types
-        if (lt.type === 'STRING' || lt.type === 'UTF8')
-            return 'VARCHAR';
-        if (lt.type === 'JSON')
-            return 'JSON';
-        if (lt.type === 'UUID')
-            return 'UUID';
-        if (lt.type === 'ENUM')
-            return 'VARCHAR';
-        // Integer types
-        if (lt.type === 'INT' || lt.type === 'INTEGER') {
-            const bits = lt.bitWidth ?? 32;
-            const signed = lt.isSigned !== false;
-            if (bits <= 8)
-                return signed ? 'TINYINT' : 'UTINYINT';
-            if (bits <= 16)
-                return signed ? 'SMALLINT' : 'USMALLINT';
-            if (bits <= 32)
-                return signed ? 'INTEGER' : 'UINTEGER';
-            return signed ? 'BIGINT' : 'UBIGINT';
-        }
-        // Decimal
-        if (lt.type === 'DECIMAL')
-            return `DECIMAL(${lt.precision ?? 18},${lt.scale ?? 0})`;
-        // Date/Time
-        if (lt.type === 'DATE')
-            return 'DATE';
-        if (lt.type === 'TIME')
-            return 'TIME';
-        if (lt.type === 'TIMESTAMP')
-            return 'TIMESTAMP';
-        // Binary
-        if (lt.type === 'BSON')
-            return 'BLOB';
-    }
-    // Fallback to physical type
-    const ct = col.converted_type;
-    if (ct === 'UTF8')
-        return 'VARCHAR';
-    if (ct === 'JSON')
-        return 'JSON';
-    if (ct === 'DATE')
-        return 'DATE';
-    if (ct === 'TIMESTAMP_MILLIS' || ct === 'TIMESTAMP_MICROS')
-        return 'TIMESTAMP';
-    if (ct === 'DECIMAL')
-        return `DECIMAL(${col.precision ?? 18},${col.scale ?? 0})`;
-    if (ct === 'INT_8')
-        return 'TINYINT';
-    if (ct === 'INT_16')
-        return 'SMALLINT';
-    if (ct === 'INT_32')
-        return 'INTEGER';
-    if (ct === 'INT_64')
-        return 'BIGINT';
-    if (ct === 'UINT_8')
-        return 'UTINYINT';
-    if (ct === 'UINT_16')
-        return 'USMALLINT';
-    if (ct === 'UINT_32')
-        return 'UINTEGER';
-    if (ct === 'UINT_64')
-        return 'UBIGINT';
-    const pt = col.type;
-    if (pt === 'BOOLEAN')
-        return 'BOOLEAN';
-    if (pt === 'INT32')
-        return 'INTEGER';
-    if (pt === 'INT64')
-        return 'BIGINT';
-    if (pt === 'INT96')
-        return 'TIMESTAMP';
-    if (pt === 'FLOAT')
-        return 'FLOAT';
-    if (pt === 'DOUBLE')
-        return 'DOUBLE';
-    if (pt === 'BYTE_ARRAY')
-        return 'BLOB';
-    if (pt === 'FIXED_LEN_BYTE_ARRAY')
-        return 'BLOB';
-    return 'VARCHAR';
-}
-/**
- * Read Parquet footer metadata from a remote URL using hyparquet.
- * Uses HTTP range requests — typically a single ~512KB fetch.
- */
-export async function readParquetMetadata(url) {
-    const { parquetMetadataAsync, asyncBufferFromUrl } = await import('hyparquet');
-    const file = await asyncBufferFromUrl({ url });
-    const metadata = await parquetMetadataAsync(file);
-    // Row count from row group metadata (no data scan needed)
-    const rowCount = metadata.row_groups.reduce((sum, rg) => sum + Number(rg.num_rows), 0);
-    // Schema from metadata (skip root element at index 0)
-    const schema = metadata.schema
-        .slice(1)
-        .filter((col) => col.num_children === undefined) // skip group elements
-        .map((col) => ({
-        name: col.name,
-        type: mapParquetType(col)
-    }));
-    // Walk depth-first to collect top-level column names (including struct parents).
-    // hyparquet serializes the schema as a flat depth-first array where the root
-    // carries `num_children` and each group element claims the next N siblings.
-    const topLevelColumns = [];
-    const root = metadata.schema[0];
-    const rootChildren = root?.num_children ?? 0;
-    let cursor = 1;
-    for (let i = 0; i < rootChildren && cursor < metadata.schema.length; i++) {
-        const el = metadata.schema[cursor];
-        if (el?.name)
-            topLevelColumns.push(el.name);
-        cursor += countSubtree(metadata.schema, cursor);
-    }
-    // GeoParquet "geo" key-value metadata
-    let geo = null;
-    let legacyGeoParquet = false;
-    const geoKv = metadata.key_value_metadata?.find((kv) => kv.key === 'geo');
-    if (geoKv) {
-        try {
-            const geoJson = JSON.parse(geoKv.value ?? '');
-            // Detect legacy GeoParquet (schema_version 0.x without "version" field).
-            // Early geopandas (<0.12) wrote schema_version instead of version.
-            // DuckDB's spatial extension rejects these files with:
-            // "Geoparquet metadata does not have a version"
-            if (geoJson.schema_version && !geoJson.version) {
-                legacyGeoParquet = true;
-            }
-            geo = {
-                primaryColumn: geoJson.primary_column ?? 'geometry',
-                columns: {}
-            };
-            if (geoJson.columns) {
-                for (const [colName, colMeta] of Object.entries(geoJson.columns)) {
-                    geo.columns[colName] = {
-                        encoding: colMeta.encoding ?? 'WKB',
-                        geometryTypes: colMeta.geometry_types ?? [],
-                        crs: colMeta.crs ?? null,
-                        bbox: colMeta.bbox
-                    };
-                }
-            }
-        }
-        catch {
-            // malformed geo metadata — ignore
-        }
-    }
-    // Created-by tool
-    const createdBy = metadata.created_by ?? null;
-    // Row group count
-    const numRowGroups = metadata.row_groups.length;
-    // Compression: collect unique codecs from first row group's columns
-    let compression = null;
-    if (numRowGroups > 0 && metadata.row_groups[0].columns) {
-        const codecs = new Set();
-        for (const col of metadata.row_groups[0].columns) {
-            const codec = col.meta_data?.codec;
-            if (codec)
-                codecs.add(codec);
-        }
-        if (codecs.size === 1) {
-            compression = [...codecs][0];
-        }
-        else if (codecs.size > 1) {
-            compression = [...codecs].join(', ');
-        }
-    }
-    return {
-        rowCount,
-        schema,
-        topLevelColumns,
-        geo,
-        legacyGeoParquet,
-        createdBy,
-        numRowGroups,
-        compression
-    };
-}
-/** Count how many schema elements belong to the subtree rooted at `start` (inclusive). */
-function countSubtree(schema, start) {
-    const el = schema[start];
-    if (!el)
-        return 0;
-    const n = el.num_children ?? 0;
-    let cursor = start + 1;
-    for (let i = 0; i < n; i++) {
-        cursor += countSubtree(schema, cursor);
-    }
-    return cursor - start;
-}
-/**
- * Extract EPSG code from GeoParquet CRS metadata.
- * Returns null for WGS84/CRS84 (no reprojection needed).
- */
-export function extractEpsgFromGeoMeta(geo) {
-    const primaryCol = geo.columns[geo.primaryColumn];
-    if (!primaryCol?.crs)
-        return null;
-    const crs = primaryCol.crs;
-    // OGC CRS84 is lon/lat WGS84
-    if (crs.type === 'name' && crs.properties?.name?.includes('CRS84'))
-        return null;
-    // PROJJSON: { "id": { "authority": "EPSG", "code": 27700 } }
-    if (crs.id?.authority === 'EPSG') {
-        const code = crs.id.code;
-        if (WGS84_CODES.has(code))
-            return null;
-        return `EPSG:${code}`;
-    }
-    return null;
-}
-/**
- * Extract normalized geometry types from GeoParquet metadata.
- * Returns the set of geometry types for the primary column.
- */
-export function extractGeometryTypes(geo) {
-    const primaryCol = geo.columns[geo.primaryColumn];
-    if (!primaryCol?.geometryTypes?.length)
-        return [];
-    const typeMap = {
-        Point: 'point',
-        LineString: 'linestring',
-        Polygon: 'polygon',
-        MultiPoint: 'multipoint',
-        MultiLineString: 'multilinestring',
-        MultiPolygon: 'multipolygon'
-    };
-    const types = [];
-    for (const raw of primaryCol.geometryTypes) {
-        // GeoParquet geometry_types may include Z/M suffixes like "Polygon Z"
-        const base = raw.split(' ')[0];
-        const mapped = typeMap[base];
-        if (mapped && !types.includes(mapped))
-            types.push(mapped);
-    }
-    return types;
-}
-/**
- * Extract bounds from GeoParquet metadata (bbox field).
- * Returns [minX, minY, maxX, maxY] or null.
- */
-export function extractBounds(geo) {
-    const primaryCol = geo.columns[geo.primaryColumn];
-    if (!primaryCol?.bbox || primaryCol.bbox.length < 4)
-        return null;
-    return [primaryCol.bbox[0], primaryCol.bbox[1], primaryCol.bbox[2], primaryCol.bbox[3]];
-}

package/dist/utils/stac-geoparquet.d.ts

@@ -1,90 +0,0 @@
-/**
- * stac-geoparquet helpers.
- *
- * Pure TypeScript, zero Svelte / DuckDB / deck.gl dependencies. Re-exported
- * through `@walkthru-earth/objex-utils` so other projects can consume the
- * detection + row-to-Item transforms without pulling the Svelte lib.
- *
- * The module is decoupled from WKB decoding: callers pass a `wkbParser`
- * callback (the objex Svelte lib threads its `parseWKB`; other consumers
- * can plug in `geoarrow-wasm`, `wkx`, or any other library).
- */
-import type { StacAsset, StacItem } from './stac.js';
-/** Minimal schema column shape. Works with hyparquet, DuckDB, Arrow. */
-export interface StacGeoparquetSchemaColumn {
-    name: string;
-    type?: string;
-}
-/** Bbox in struct shape as produced by DuckDB's `bbox struct(xmin,ymin,xmax,ymax)`. */
-export interface StacBboxStruct {
-    xmin: number;
-    ymin: number;
-    xmax: number;
-    ymax: number;
-}
-/** Generic Record shape representing a single stac-geoparquet row after DuckDB decoding. */
-export type StacGeoparquetRow = Record<string, unknown>;
-export interface StacRowToItemOptions {
-    /**
-     * Decoder for the geometry column. Accepts a Uint8Array of WKB bytes and
-     * returns a GeoJSON geometry object (or null on failure).
-     *
-     * Consumers in the objex Svelte lib should pass `parseWKB` from
-     * `@walkthru-earth/objex-utils`. Other projects can use any WKB library.
-     */
-    wkbParser?: (bytes: Uint8Array) => unknown;
-    /**
-     * Column name holding the WKB bytes. Defaults to `'geom_wkb'` because the
-     * recommended SQL projection is `ST_AsWKB(geometry) AS geom_wkb`.
-     */
-    wkbColumn?: string;
-    /** Override the column holding the pre-decoded GeoJSON geometry, when available. */
-    geometryColumn?: string;
-}
-/** Columns every stac-geoparquet file MUST carry per the stac-geoparquet spec. */
-export declare const STAC_GEOPARQUET_REQUIRED_COLUMNS: readonly ["stac_version", "type", "geometry", "assets"];
-/**
- * Detect stac-geoparquet by presence of the required STAC columns.
- *
- * Deliberately type-agnostic: some pipelines know the type (DuckDB DESCRIBE,
- * Arrow Field), others only have the name list (hyparquet schema walk). The
- * set of names is sufficient for routing.
- */
-export declare function isStacGeoparquetSchema(schema: StacGeoparquetSchemaColumn[]): boolean;
-/**
- * Flatten a DuckDB `struct(xmin,ymin,xmax,ymax)` bbox to the `[minX, minY, maxX, maxY]`
- * array shape that STAC Items and deck.gl-geotiff MosaicLayer expect.
- *
- * Pass-through for arrays so callers that already have `[minX,minY,maxX,maxY]`
- * shape (e.g. from a Feature's `bbox` field) don't need a separate path.
- */
-export declare function flattenStacBbox(bbox: StacBboxStruct | number[] | null | undefined): [number, number, number, number] | null;
-/**
- * Resolve a possibly-relative STAC asset href against the parquet file URL.
- *
- * `./foo.tif` or `foo.tif` → absolute against `baseUrl`. Absolute URLs
- * (`http(s)://`, `s3://`, `gs://`, etc.) are returned unchanged.
- */
-export declare function resolveStacAssetHref(href: string, baseUrl: string): string;
-/**
- * Pick the "primary" asset from a STAC Item's `assets` map.
- *
- * Priority: caller-specified `preferredKeys` → `data` key → first asset with
- * `roles` containing `'data'` → first asset. Returns `null` if the map is
- * empty or not an object.
- */
-export declare function pickStacPrimaryAsset(assets: Record<string, StacAsset> | null | undefined, preferredKeys?: readonly string[]): {
-    key: string;
-    asset: StacAsset;
-} | null;
-/**
- * Convert one stac-geoparquet row into a standard STAC Item JSON object.
- *
- * Handles:
- *   - `assets` named-struct flattening + relative href resolution
- *   - `bbox` struct → `[minX, minY, maxX, maxY]` array
- *   - Optional WKB geometry → GeoJSON via `opts.wkbParser`
- *   - `datetime` → ISO string (passes through already-string values)
- *   - Promotes `properties.*` columns (`proj:*`, `datetime`) onto `item.properties`
- */
-export declare function stacRowToItem(row: StacGeoparquetRow, baseUrl: string, opts?: StacRowToItemOptions): StacItem;