@secondlayer/sdk 5.4.0 → 5.6.0

package/README.md

@@ -14,11 +14,15 @@ bun add @secondlayer/sdk
 import { SecondLayer } from "@secondlayer/sdk";
 
 const sl = new SecondLayer({
-  apiKey: "sk-sl_...",                          // or session token
+  apiKey: "sk-sl_...",                          // or `sl login` session token
   baseUrl: "https://api.secondlayer.tools",     // default
 });
 ```
 
+Reads are public during open beta — no key needed. Writes require an `sk-sl_`
+API key, created in the platform console at
+https://secondlayer.tools/platform/api-keys.
+
 ## Mental model
 
 - `sl.streams` reads raw ordered L1 events from Stacks Streams.
@@ -27,10 +31,7 @@ const sl = new SecondLayer({
 
 ## Stacks Streams
 
-Typed L1 HTTP client.
-
-`sk-sl_streams_status_public` is a public, non-secret Free-tier key used by the
-Second Layer status page. Production apps should use their own Streams API key.
+Typed L1 HTTP client. Reads are public — no key needed.
 
 ```typescript
 const tip = await sl.streams.tip();
@@ -49,7 +50,7 @@ console.log({ tip, firstCursor: page.events[0]?.cursor });
 import { createStreamsClient } from "@secondlayer/sdk";
 
 const streams = createStreamsClient({
-  apiKey: process.env.SECONDLAYER_API_KEY!,
+  apiKey: process.env.SL_SERVICE_KEY!, // sk-sl_...
 });
 ```
 
@@ -70,13 +71,7 @@ inside `onBatch`, then return the cursor you committed. It exits when
 `maxPages`, `maxEmptyPolls`, or `signal` stops it.
 
 ```typescript
-import { createStreamsClient } from "@secondlayer/sdk";
-
-const client = createStreamsClient({
-  apiKey: process.env.SECONDLAYER_API_KEY!,
-});
-
-await client.events.consume({
+await streams.events.consume({
   types: ["ft_transfer"],
   batchSize: 100,
   maxPages: 1,
@@ -95,16 +90,10 @@ Use `client.events.stream` for live processors and watch-style apps. It follows
 the tip indefinitely. Stop it with an `AbortSignal`.
 
 ```typescript
-import { createStreamsClient } from "@secondlayer/sdk";
-
-const client = createStreamsClient({
-  apiKey: process.env.SECONDLAYER_API_KEY!,
-});
-
 const abort = new AbortController();
 process.once("SIGINT", () => abort.abort());
 
-for await (const event of client.events.stream({
+for await (const event of streams.events.stream({
   types: ["ft_transfer"],
   batchSize: 100,
   signal: abort.signal,
@@ -116,17 +105,9 @@ for await (const event of client.events.stream({
 Decoder helper.
 
 ```typescript
-import {
-  createStreamsClient,
-  decodeFtTransfer,
-  isFtTransfer,
-} from "@secondlayer/sdk";
-
-const client = createStreamsClient({
-  apiKey: process.env.SECONDLAYER_API_KEY!,
-});
+import { decodeFtTransfer, isFtTransfer } from "@secondlayer/sdk";
 
-for await (const event of client.events.stream({ types: ["ft_transfer"] })) {
+for await (const event of streams.events.stream({ types: ["ft_transfer"] })) {
   if (!isFtTransfer(event)) continue;
   const transfer = decodeFtTransfer(event);
   console.log(transfer.decoded_payload);
@@ -172,7 +153,7 @@ for await (const transfer of sl.index.ftTransfers.walk({
 
 Deploy and query app-specific L3 tables.
 
-Subgraphs and subscriptions live on the platform API alongside Streams and Index. Authenticate with your `sk-sl_*` key — no extra setup, no tenant URL.
+Subgraphs and subscriptions live on the platform API alongside Streams and Index. Deploying and managing them needs your `sk-sl_` key — no extra setup, no tenant URL.
 
 ```typescript
 // List

package/dist/index.d.ts

@@ -216,6 +216,14 @@ type IndexStxBurn = IndexEventBase & {
 	sender: string
 	amount: string
 };
+type IndexStxLock = IndexEventBase & {
+	event_type: "stx_lock"
+	sender: string
+	amount: string
+	payload: {
+		unlock_height: string | null
+	}
+};
 type IndexFtMint = IndexEventBase & {
 	event_type: "ft_mint"
 	asset_identifier: string
@@ -249,7 +257,7 @@ type IndexPrint = IndexEventBase & {
 	}
 };
 /** Decoded chain event, discriminated by `event_type`. */
-type IndexEvent = IndexFtTransfer | IndexNftTransfer | IndexStxTransfer | IndexStxMint | IndexStxBurn | IndexFtMint | IndexFtBurn | IndexNftMint | IndexNftBurn | IndexPrint;
+type IndexEvent = IndexFtTransfer | IndexNftTransfer | IndexStxTransfer | IndexStxMint | IndexStxBurn | IndexStxLock | IndexFtMint | IndexFtBurn | IndexNftMint | IndexNftBurn | IndexPrint;
 type IndexEventType = IndexEvent["event_type"];
 type EventsEnvelope = {
 	events: IndexEvent[]
@@ -654,6 +662,27 @@ declare function isStxBurn(event: StreamsEvent): event is StreamsEvent & {
 	event_type: "stx_burn"
 };
 declare function decodeStxBurn(event: StreamsEvent): DecodedStxBurn;
+type DecodedStxLockPayload = {
+	sender: string
+	amount: string
+	payload: {
+		unlock_height: string | null
+	}
+};
+type DecodedStxLock = {
+	cursor: string
+	block_height: number
+	tx_id: string
+	tx_index: number
+	event_index: number
+	event_type: "stx_lock"
+	decoded_payload: DecodedStxLockPayload
+	source_cursor: string
+};
+declare function isStxLock(event: StreamsEvent): event is StreamsEvent & {
+	event_type: "stx_lock"
+};
+declare function decodeStxLock(event: StreamsEvent): DecodedStxLock;
 type DecodedFtMintPayload = {
 	asset_identifier: string
 	contract_id: string
@@ -780,7 +809,89 @@ type DecodedEventColumns = {
 	/** JSONB overflow for non-flat types (e.g. print's decoded value). */
 	payload?: unknown
 };
-type DecodedEventRow = DecodedFtTransfer | DecodedNftTransfer | DecodedStxTransfer | DecodedStxMint | DecodedStxBurn | DecodedFtMint | DecodedFtBurn | DecodedNftMint | DecodedNftBurn | DecodedPrint;
+type DecodedEventRow = DecodedFtTransfer | DecodedNftTransfer | DecodedStxTransfer | DecodedStxMint | DecodedStxBurn | DecodedStxLock | DecodedFtMint | DecodedFtBurn | DecodedNftMint | DecodedNftBurn | DecodedPrint;
+/**
+* Typed client for the Foundation Datasets REST API (`/v1/datasets/*`).
+*
+* Most datasets are cursor-paginated event lists with a uniform `list`/`walk`
+* surface; a few (bns names/namespaces/resolve, network-health) are
+* offset/single-object/summary and get bespoke methods. Query params are typed
+* per dataset; rows are `DatasetRow` (JSON) in v1 — per-dataset row interfaces
+* are a fast-follow.
+*/
+/** A dataset row — flat JSON object. Per-dataset interfaces are a follow-up. */
+type DatasetRow = Record<string, unknown>;
+/** Filters shared by every cursor-paginated dataset. */
+interface CursorListParams {
+	cursor?: string;
+	limit?: number;
+	fromBlock?: number;
+	toBlock?: number;
+}
+interface CursorEnvelope {
+	rows: DatasetRow[];
+	next_cursor: string | null;
+	tip?: {
+		block_height: number
+	};
+}
+type RangeFilters = CursorListParams;
+type Pox4CallsParams = RangeFilters & {
+	functionName?: string
+	stacker?: string
+	delegateTo?: string
+	signerKey?: string
+	rewardCycle?: number
+	/** Any-role: matches caller OR stacker OR delegate_to. */
+	address?: string
+};
+/** Cursor-paginated dataset slugs → REST path + envelope row key. */
+declare const CURSOR_SLUGS: Record<string, {
+	path: string
+	rowKey: string
+}>;
+declare class Datasets extends BaseClient {
+	constructor(options?: Partial<SecondLayerOptions>);
+	/** Dataset catalog + freshness (the discovery endpoint). */
+	listDatasets(): Promise<unknown>;
+	/**
+	* Generic cursor query by slug — used by the CLI. Params are passed through as
+	* REST query keys (snake_case), so callers can use the documented filter names
+	* directly. Throws for non-cursor (bespoke) datasets.
+	*/
+	query(slug: string, params?: Record<string, unknown>): Promise<CursorEnvelope>;
+	readonly stxTransfers;
+	readonly sbtcEvents;
+	readonly sbtcTokenEvents;
+	readonly pox4Calls;
+	readonly bnsEvents;
+	readonly bnsNamespaceEvents;
+	readonly bnsMarketplaceEvents;
+	/** BNS names — offset-paginated. */
+	bnsNames(params?: {
+		namespace?: string
+		owner?: string
+		limit?: number
+		offset?: number
+	}): Promise<{
+		names: DatasetRow[]
+	}>;
+	/** All BNS namespaces (no pagination). */
+	bnsNamespaces(): Promise<{
+		namespaces: DatasetRow[]
+	}>;
+	/** Resolve a fully-qualified BNS name → single record. */
+	bnsResolve(fqn: string): Promise<{
+		name: DatasetRow | null
+	}>;
+	/** Network health summary. */
+	networkHealth(): Promise<{
+		summary: DatasetRow
+	}>;
+	private get;
+	private buildParams;
+	private cursorDataset;
+}
 import { SubgraphAgentSchema as SubgraphAgentSchema3, SubgraphSpecFormat as SubgraphSpecFormat2, SubgraphSpecOptions as SubgraphSpecOptions3 } from "@secondlayer/shared/subgraphs/spec";
 /**
 * Error thrown by {@link SecondLayer} when an API request fails.
@@ -899,4 +1010,4 @@ declare function toJsonSafe(value: unknown): unknown;
 /** Decode a hex-encoded Clarity value to JSON-safe JS (uints as strings,
 *  buffers as `0x…` hex, tuples as objects). Returns the input hex on failure. */
 declare function decodeClarityValue(hex: string): unknown;
-export { verifyWebhookSignature, toJsonSafe, isStxTransfer, isStxMint, isStxBurn, isPrint, isNftTransfer, isNftMint, isNftBurn, isFtTransfer, isFtMint, isFtBurn, getSubgraph, decodeStxTransfer, decodeStxMint, decodeStxBurn, decodePrint, decodeNftTransfer, decodeNftMint, decodeNftBurn, decodeFtTransfer, decodeFtMint, decodeFtBurn, decodeClarityValue, createStreamsClient, VersionConflictError, ValidationError, UpdateSubscriptionRequest2 as UpdateSubscriptionRequest, Subscriptions, SubscriptionSummary2 as SubscriptionSummary, SubscriptionStatus, SubscriptionRuntime, SubscriptionFormat, SubscriptionDetail2 as SubscriptionDetail, Subgraphs, SubgraphSpecOptions3 as SubgraphSpecOptions, SubgraphSpecFormat2 as SubgraphSpecFormat, SubgraphAgentSchema3 as SubgraphAgentSchema, StreamsTip, StreamsServerError, StreamsReorgsListParams, StreamsReorgsListEnvelope, StreamsReorg, StreamsEventsStreamParams, StreamsEventsListParams, StreamsEventsListEnvelope, StreamsEventsEnvelope, StreamsEventsConsumeResult, StreamsEventsConsumeParams, StreamsEventType, StreamsEventPayload, StreamsEvent, StreamsClient, StreamsCanonicalBlock, SecondLayerOptions, SecondLayer, RotateSecretResponse2 as RotateSecretResponse, ReplayResult2 as ReplayResult, RateLimitError, NftTransfersWalkParams, NftTransfersListParams, NftTransfersEnvelope, NftTransferPayload, NftTransferEvent, NftTransfer, IndexTip, IndexEventType, IndexEvent, IndexContractCall, Index, FtTransfersWalkParams, FtTransfersListParams, FtTransfersEnvelope, FtTransferPayload, FtTransferEvent, FtTransfer, FetchLike2 as FetchLike, EventsWalkParams, EventsListParams, EventsEnvelope, DeliveryRow2 as DeliveryRow, DecodedStxTransferPayload, DecodedStxTransfer, DecodedStxMintPayload, DecodedStxMint, DecodedStxBurnPayload, DecodedStxBurn, DecodedPrintValue, DecodedPrintPayload, DecodedPrint, DecodedNftTransferPayload, DecodedNftTransfer, DecodedNftMintPayload, DecodedNftMint, DecodedNftBurnPayload, DecodedNftBurn, DecodedFtTransferPayload, DecodedFtTransfer, DecodedFtMintPayload, DecodedFtMint, DecodedFtBurnPayload, DecodedFtBurn, DecodedEventRow, DecodedEventColumns, DeadRow2 as DeadRow, CreateSubscriptionResponse2 as CreateSubscriptionResponse, CreateSubscriptionRequest2 as CreateSubscriptionRequest, ContractCallsWalkParams, ContractCallsListParams, ContractCallsEnvelope, AuthError, ApiError };
+export { verifyWebhookSignature, toJsonSafe, isStxTransfer, isStxMint, isStxLock, isStxBurn, isPrint, isNftTransfer, isNftMint, isNftBurn, isFtTransfer, isFtMint, isFtBurn, getSubgraph, decodeStxTransfer, decodeStxMint, decodeStxLock, decodeStxBurn, decodePrint, decodeNftTransfer, decodeNftMint, decodeNftBurn, decodeFtTransfer, decodeFtMint, decodeFtBurn, decodeClarityValue, createStreamsClient, VersionConflictError, ValidationError, UpdateSubscriptionRequest2 as UpdateSubscriptionRequest, Subscriptions, SubscriptionSummary2 as SubscriptionSummary, SubscriptionStatus, SubscriptionRuntime, SubscriptionFormat, SubscriptionDetail2 as SubscriptionDetail, Subgraphs, SubgraphSpecOptions3 as SubgraphSpecOptions, SubgraphSpecFormat2 as SubgraphSpecFormat, SubgraphAgentSchema3 as SubgraphAgentSchema, StreamsTip, StreamsServerError, StreamsReorgsListParams, StreamsReorgsListEnvelope, StreamsReorg, StreamsEventsStreamParams, StreamsEventsListParams, StreamsEventsListEnvelope, StreamsEventsEnvelope, StreamsEventsConsumeResult, StreamsEventsConsumeParams, StreamsEventType, StreamsEventPayload, StreamsEvent, StreamsClient, StreamsCanonicalBlock, SecondLayerOptions, SecondLayer, RotateSecretResponse2 as RotateSecretResponse, ReplayResult2 as ReplayResult, RateLimitError, Pox4CallsParams, NftTransfersWalkParams, NftTransfersListParams, NftTransfersEnvelope, NftTransferPayload, NftTransferEvent, NftTransfer, IndexTip, IndexEventType, IndexEvent, IndexContractCall, Index, FtTransfersWalkParams, FtTransfersListParams, FtTransfersEnvelope, FtTransferPayload, FtTransferEvent, FtTransfer, FetchLike2 as FetchLike, EventsWalkParams, EventsListParams, EventsEnvelope, DeliveryRow2 as DeliveryRow, DecodedStxTransferPayload, DecodedStxTransfer, DecodedStxMintPayload, DecodedStxMint, DecodedStxLockPayload, DecodedStxLock, DecodedStxBurnPayload, DecodedStxBurn, DecodedPrintValue, DecodedPrintPayload, DecodedPrint, DecodedNftTransferPayload, DecodedNftTransfer, DecodedNftMintPayload, DecodedNftMint, DecodedNftBurnPayload, DecodedNftBurn, DecodedFtTransferPayload, DecodedFtTransfer, DecodedFtMintPayload, DecodedFtMint, DecodedFtBurnPayload, DecodedFtBurn, DecodedEventRow, DecodedEventColumns, DeadRow2 as DeadRow, Datasets, DatasetRow, CursorListParams, CursorEnvelope, CreateSubscriptionResponse2 as CreateSubscriptionResponse, CreateSubscriptionRequest2 as CreateSubscriptionRequest, ContractCallsWalkParams, ContractCallsListParams, ContractCallsEnvelope, CURSOR_SLUGS, AuthError, ApiError };

package/dist/index.js

@@ -143,7 +143,10 @@ function serializeWhere(where) {
           continue;
         if (op === "eq") {
           filters[col] = String(opValue);
-        } else if (["neq", "gt", "gte", "lt", "lte"].includes(op)) {
+        } else if (op === "in" || op === "notIn") {
+          const arr = Array.isArray(opValue) ? opValue : [opValue];
+          filters[`${col}.${op}`] = arr.map((v) => String(v)).join(",");
+        } else if (["neq", "gt", "gte", "lt", "lte", "like"].includes(op)) {
           filters[`${col}.${op}`] = String(opValue);
         }
       }
@@ -257,18 +260,10 @@ class Subgraphs extends BaseClient {
         let sort;
         let order;
         if (options.orderBy) {
-          const entries = Object.entries(options.orderBy);
+          const entries = Array.isArray(options.orderBy) ? options.orderBy : Object.entries(options.orderBy);
           if (entries.length > 0) {
-            if (entries.length > 1) {
-              const extra = entries.slice(1).map(([col]) => col).join(", ");
-              throw new Error(`orderBy supports only one column; remove extra keys: ${extra}`);
-            }
-            const first = entries[0];
-            if (first) {
-              const [col, dir] = first;
-              sort = resolveOrderByColumn(col);
-              order = dir ?? "asc";
-            }
+            sort = entries.map(([col]) => resolveOrderByColumn(col)).join(",");
+            order = entries.map(([, dir]) => dir ?? "asc").join(",");
           }
         }
         const params = {
@@ -944,13 +939,16 @@ function requireString3(payload, field, eventType) {
 function optionalString(value) {
   return typeof value === "string" && value.length > 0 ? value : null;
 }
-function requireAmount(payload, eventType) {
-  const amount = requireString3(payload, "amount", eventType);
+function requireAmountField(payload, field, eventType) {
+  const amount = requireString3(payload, field, eventType);
   if (!/^(0|[1-9]\d*)$/.test(amount)) {
-    throw new Error(`${eventType} payload has malformed amount`);
+    throw new Error(`${eventType} payload has malformed ${field}`);
   }
   return amount;
 }
+function requireAmount(payload, eventType) {
+  return requireAmountField(payload, "amount", eventType);
+}
 function parseAssetIdentifier3(assetIdentifier, eventType) {
   const [contractId, tokenName] = assetIdentifier.split("::");
   if (!contractId) {
@@ -1034,6 +1032,20 @@ function decodeStxBurn(event) {
     amount: requireAmount(payload, "stx_burn")
   });
 }
+function isStxLock(event) {
+  return event.event_type === "stx_lock";
+}
+function decodeStxLock(event) {
+  if (!isStxLock(event)) {
+    throw new Error(`Expected stx_lock event, got ${event.event_type}`);
+  }
+  const payload = event.payload;
+  return decodedRow(event, "stx_lock", {
+    sender: requireString3(payload, "locked_address", "stx_lock"),
+    amount: requireAmountField(payload, "locked_amount", "stx_lock"),
+    payload: { unlock_height: optionalString(payload.unlock_height) }
+  });
+}
 // src/streams/token-mint-burn.ts
 function assetFields(event, eventType) {
   const assetIdentifier = requireString3(event.payload, "asset_identifier", eventType);
@@ -1163,6 +1175,126 @@ var STREAMS_EVENT_TYPES = [
   "nft_burn",
   "print"
 ];
+// src/datasets/client.ts
+function appendParam(params, name, value) {
+  if (value === undefined || value === null)
+    return;
+  params.set(name, String(value));
+}
+var PARAM_KEYS = {
+  fromBlock: "from_block",
+  toBlock: "to_block",
+  functionName: "function_name",
+  delegateTo: "delegate_to",
+  signerKey: "signer_key",
+  rewardCycle: "reward_cycle",
+  eventType: "event_type",
+  bnsId: "bns_id"
+};
+var CURSOR_SLUGS = {
+  "stx-transfers": { path: "stx-transfers", rowKey: "events" },
+  "sbtc-events": { path: "sbtc/events", rowKey: "events" },
+  "sbtc-token-events": { path: "sbtc/token-events", rowKey: "events" },
+  "pox-4-calls": { path: "pox-4/calls", rowKey: "calls" },
+  "bns-events": { path: "bns/events", rowKey: "events" },
+  "bns-namespace-events": { path: "bns/namespace-events", rowKey: "events" },
+  "bns-marketplace-events": {
+    path: "bns/marketplace-events",
+    rowKey: "events"
+  }
+};
+
+class Datasets extends BaseClient {
+  constructor(options = {}) {
+    super(options);
+  }
+  listDatasets() {
+    return this.request("GET", "/v1/datasets");
+  }
+  async query(slug, params = {}) {
+    const d = CURSOR_SLUGS[slug];
+    if (!d) {
+      throw new Error(`unknown cursor dataset "${slug}" (use one of: ${Object.keys(CURSOR_SLUGS).join(", ")})`);
+    }
+    const env = await this.get(d.path, this.buildParams(params));
+    return {
+      rows: env[d.rowKey] ?? [],
+      next_cursor: env.next_cursor ?? null,
+      tip: env.tip
+    };
+  }
+  stxTransfers = this.cursorDataset("stx-transfers", "events");
+  sbtcEvents = this.cursorDataset("sbtc/events", "events");
+  sbtcTokenEvents = this.cursorDataset("sbtc/token-events", "events");
+  pox4Calls = this.cursorDataset("pox-4/calls", "calls");
+  bnsEvents = this.cursorDataset("bns/events", "events");
+  bnsNamespaceEvents = this.cursorDataset("bns/namespace-events", "events");
+  bnsMarketplaceEvents = this.cursorDataset("bns/marketplace-events", "events");
+  bnsNames(params = {}) {
+    const sp = new URLSearchParams;
+    appendParam(sp, "namespace", params.namespace);
+    appendParam(sp, "owner", params.owner);
+    appendParam(sp, "limit", params.limit);
+    appendParam(sp, "offset", params.offset);
+    return this.get("bns/names", sp);
+  }
+  bnsNamespaces() {
+    return this.get("bns/namespaces", new URLSearchParams);
+  }
+  bnsResolve(fqn) {
+    const sp = new URLSearchParams;
+    sp.set("fqn", fqn);
+    return this.get("bns/resolve", sp);
+  }
+  networkHealth() {
+    return this.get("network-health/summary", new URLSearchParams);
+  }
+  get(path, sp) {
+    const qs = sp.toString();
+    return this.request("GET", `/v1/datasets/${path}${qs ? `?${qs}` : ""}`);
+  }
+  buildParams(params) {
+    const sp = new URLSearchParams;
+    for (const [k, v] of Object.entries(params)) {
+      if (v === undefined || v === null || k === "batchSize" || k === "signal")
+        continue;
+      appendParam(sp, PARAM_KEYS[k] ?? k, v);
+    }
+    return sp;
+  }
+  cursorDataset(path, rowKey) {
+    const list = async (params = {}) => {
+      const envelope = await this.get(path, this.buildParams(params));
+      return {
+        rows: envelope[rowKey] ?? [],
+        next_cursor: envelope.next_cursor ?? null,
+        tip: envelope.tip
+      };
+    };
+    const walk = async function* (params = {}) {
+      const batchSize = params.batchSize ?? 200;
+      let cursor = params.cursor ?? null;
+      let first = true;
+      while (!params.signal?.aborted) {
+        const env = await list({
+          ...params,
+          limit: batchSize,
+          cursor: first ? params.cursor : cursor ?? undefined
+        });
+        for (const row of env.rows) {
+          if (params.signal?.aborted)
+            return;
+          yield row;
+        }
+        if (!env.next_cursor || env.next_cursor === cursor || env.rows.length < batchSize)
+          return;
+        cursor = env.next_cursor;
+        first = false;
+      }
+    }.bind(this);
+    return { list, walk };
+  }
+}
 // src/webhooks.ts
 import {
   verify
@@ -1211,6 +1343,7 @@ export {
   toJsonSafe,
   isStxTransfer,
   isStxMint,
+  isStxLock,
   isStxBurn,
   isPrint,
   isNftTransfer,
@@ -1222,6 +1355,7 @@ export {
   getSubgraph,
   decodeStxTransfer,
   decodeStxMint,
+  decodeStxLock,
   decodeStxBurn,
   decodePrint,
   decodeNftTransfer,
@@ -1240,9 +1374,11 @@ export {
   SecondLayer,
   RateLimitError,
   Index,
+  Datasets,
+  CURSOR_SLUGS,
   AuthError,
   ApiError
 };
 
-//# debugId=9D4DDE30AE2D8C2F64756E2164756E21
+//# debugId=0E97B24861D9205A64756E2164756E21
 //# sourceMappingURL=index.js.map