@hatk/hatk 0.0.1-alpha.11 → 0.0.1-alpha.111

package/dist/spaces/viewer.js

@@ -0,0 +1,167 @@
+/**
+ * Which spaces a given viewer may be shown.
+ *
+ * The question has exactly one authoritative answer, and hatk is not the one
+ * holding it: a space's authority decides who may read it, at the moment it
+ * mints a credential, from records and rules that live on the community's own
+ * host. Re-deriving that here — reading the access and membership records out
+ * of the index and evaluating them — would be a second implementation of
+ * somebody else's authorization, drifting from it in exactly the cases that
+ * matter. Ejected members keep their content readable in the alpha; an invites
+ * space is write-for-anyone and read-for-owner; a host may change its rules
+ * without telling us.
+ *
+ * So the check is the real thing: ask the authority to mint a credential as
+ * this viewer, and take the answer. It succeeds precisely when the viewer may
+ * read the space, because that is the same call their own browser would make.
+ *
+ * What that costs is a round trip per space, so the answer is cached — which
+ * means revocation lags by up to the cache's lifetime. Worth stating plainly:
+ * somebody ejected from a community may still be served that community's rows
+ * for a few minutes. The alternative is two round trips on every request, and
+ * the space host itself already lets a minted credential outlive a revocation
+ * by up to ten minutes.
+ */
+import { emit } from "../logger.js";
+import { mintSpaceCredential, isSpaceGone } from "./credential.js";
+import { listSpaceWatches } from "./store.js";
+/** How long a viewer's readable set is trusted before it is checked again. */
+const TTL_MS = 5 * 60 * 1000;
+/** Enough for a community's worth of spaces without opening a socket per space. */
+const CONCURRENCY = 6;
+/**
+ * Viewers held at once. Past this the oldest entry goes — a cache that grows
+ * with every account that has ever signed in is a leak, and the cost of a miss
+ * is one round trip.
+ */
+const MAX_VIEWERS = 1000;
+const cache = new Map();
+/**
+ * Resolutions in flight, one per viewer. A page fires several requests at
+ * once and every one of them misses the same cold cache; without this each
+ * would mint its own credential per space, and a member landing on the home
+ * page cost six times what it needed to.
+ */
+const inFlight = new Map();
+function entryFor(viewerDid) {
+    const entry = cache.get(viewerDid);
+    if (!entry)
+        return undefined;
+    if (entry.expiresAt <= Date.now()) {
+        cache.delete(viewerDid);
+        return undefined;
+    }
+    // Re-inserted so iteration order is least-recently-used first.
+    cache.delete(viewerDid);
+    cache.set(viewerDid, entry);
+    return entry;
+}
+function store(viewerDid, credentials) {
+    const entry = { expiresAt: Date.now() + TTL_MS, credentials };
+    cache.set(viewerDid, entry);
+    while (cache.size > MAX_VIEWERS) {
+        const oldest = cache.keys().next();
+        if (oldest.done)
+            break;
+        cache.delete(oldest.value);
+    }
+    return entry;
+}
+async function inBatches(items, size, fn) {
+    const out = [];
+    for (let i = 0; i < items.length; i += size) {
+        out.push(...(await Promise.all(items.slice(i, i + size).map(fn))));
+    }
+    return out;
+}
+function resolve(oauth, viewerDid) {
+    const pending = inFlight.get(viewerDid);
+    if (pending)
+        return pending;
+    const task = resolveNow(oauth, viewerDid).finally(() => {
+        if (inFlight.get(viewerDid) === task)
+            inFlight.delete(viewerDid);
+    });
+    inFlight.set(viewerDid, task);
+    return task;
+}
+async function resolveNow(oauth, viewerDid) {
+    const watches = await listSpaceWatches();
+    const credentials = new Map();
+    if (watches.length === 0)
+        return store(viewerDid, credentials);
+    const elapsed = Date.now();
+    await inBatches(watches, CONCURRENCY, async (watch) => {
+        try {
+            credentials.set(watch.space, await mintSpaceCredential(oauth, watch.space, viewerDid));
+        }
+        catch (err) {
+            // Every refusal is a no, and a refusal is the ordinary shape of "not a
+            // member" rather than a fault worth reporting. A space that has been
+            // deleted is a no for everybody and the sweep will stop following it.
+            credentials.set(watch.space, null);
+            if (isSpaceGone(err))
+                return;
+        }
+    });
+    const readable = [...credentials].filter(([, c]) => c !== null).length;
+    emit('spaces', 'viewer_resolved', {
+        viewer_did: viewerDid,
+        checked: watches.length,
+        readable,
+        duration_ms: Date.now() - elapsed,
+    });
+    return store(viewerDid, credentials);
+}
+/**
+ * The spaces this viewer may be shown, as the scope for a request.
+ *
+ * Empty for a signed-out visitor, always: obtaining a credential begins with a
+ * delegation token from the reader's own PDS, so there is no anonymous read
+ * path into a space at all. `readableBy: ["public"]` means any authenticated
+ * reader, never anyone.
+ */
+export async function readableSpacesFor(oauth, viewer) {
+    if (!oauth || !viewer)
+        return [];
+    const entry = entryFor(viewer.did) ?? (await resolve(oauth, viewer.did));
+    return [...entry.credentials].filter(([, c]) => c !== null).map(([space]) => space);
+}
+/**
+ * This viewer's own credential for a space, or null if they may not read it.
+ *
+ * For the reads that cannot go through the index — a blob, which has no public
+ * URL by design and must be fetched from the repo that holds it with the same
+ * credential as the record naming it.
+ */
+export async function viewerCredential(oauth, viewer, space) {
+    if (!oauth || !viewer)
+        return null;
+    const entry = entryFor(viewer.did) ?? (await resolve(oauth, viewer.did));
+    const cached = entry.credentials.get(space);
+    if (cached !== undefined) {
+        // A credential can expire inside the entry's own lifetime; the answer to
+        // "may they read it" outlives the token that proved it.
+        if (cached === null)
+            return null;
+        if (cached.expiresAt > Date.now())
+            return cached;
+    }
+    try {
+        const credential = await mintSpaceCredential(oauth, space, viewer.did);
+        entry.credentials.set(space, credential);
+        return credential;
+    }
+    catch {
+        entry.credentials.set(space, null);
+        return null;
+    }
+}
+/** Drop a viewer's cached answer — after they sign out, or to stop honouring it early. */
+export function forgetViewerSpaces(viewerDid) {
+    cache.delete(viewerDid);
+}
+export function resetViewerSpaces() {
+    cache.clear();
+    inFlight.clear();
+}

package/dist/spaces/visibility.d.ts

@@ -0,0 +1,57 @@
+/**
+ * Which permissioned spaces the read in flight is allowed to serve.
+ *
+ * Space records are not public data. A space's authority decides who may read
+ * it, and it decides that one caller at a time — so a row indexed out of a
+ * space carries an audience, and serving it to a request that has not proven
+ * it belongs to that audience discloses private data no matter how the query
+ * was written.
+ *
+ * hatk has no other per-row visibility concept. The takedown join is
+ * viewer-independent and `privateCollections` is all-or-nothing, so neither
+ * could carry this. The rule here is instead:
+ *
+ *   a row with `space IS NULL` is public repo data and always readable;
+ *   a row with a space is readable only inside a scope that names that space.
+ *
+ * The default is an empty scope, which serves no space rows at all. That is
+ * deliberate: a read path nobody remembered to scope fails closed and shows a
+ * member nothing, rather than failing open and showing a stranger everything.
+ * Every query over a record table applies `spaceFilterSql`; the scope is
+ * established per request by whoever established the viewer.
+ */
+/**
+ * Run `fn` with exactly these spaces readable.
+ *
+ * Replaces rather than extends any enclosing scope: widening what a nested read
+ * may see is never what a caller means, and a scope that only ever narrows is
+ * one that can be reasoned about locally.
+ */
+export declare function withReadableSpaces<T>(spaces: Iterable<string>, fn: () => T): T;
+/**
+ * Set the readable spaces for the rest of the current async context.
+ *
+ * `withReadableSpaces` wants a callback, and a request handler is a long body
+ * rather than something to wrap — restructuring it around a closure to hold a
+ * scope would be the tail wagging the dog. A server handler already runs in its
+ * own async context per request, which is the case `enterWith` exists for.
+ */
+export declare function enterReadableSpaces(spaces: Iterable<string>): void;
+/** The spaces this read may serve. Empty outside any scope. */
+export declare function readableSpaces(): ReadonlySet<string>;
+/** Whether a space would be served to the read in flight. */
+export declare function isSpaceReadable(space: string | null | undefined): boolean;
+/**
+ * The space gate as a SQL predicate, for a table aliased `alias` (pass '' for
+ * an unaliased table).
+ *
+ * `startIdx` is the next free `$N` placeholder; the returned `nextIdx` is the
+ * next one after this predicate's own. With nothing readable the predicate
+ * binds no parameters at all, which is the shape almost every request takes.
+ */
+export declare function spaceFilterSql(alias: string, startIdx: number): {
+    sql: string;
+    params: string[];
+    nextIdx: number;
+};
+//# sourceMappingURL=visibility.d.ts.map

package/dist/spaces/visibility.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"visibility.d.ts","sourceRoot":"","sources":["../../src/spaces/visibility.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAaH;;;;;;GAMG;AACH,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,EAAE,EAAE,EAAE,MAAM,CAAC,GAAG,CAAC,CAE9E;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,QAAQ,CAAC,MAAM,CAAC,GAAG,IAAI,CAElE;AAED,+DAA+D;AAC/D,wBAAgB,cAAc,IAAI,WAAW,CAAC,MAAM,CAAC,CAEpD;AAED,6DAA6D;AAC7D,wBAAgB,eAAe,CAAC,KAAK,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GAAG,OAAO,CAGzE;AAED;;;;;;;GAOG;AACH,wBAAgB,cAAc,CAAC,KAAK,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,GAAG;IAAE,GAAG,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,EAAE,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,CAUlH"}

package/dist/spaces/visibility.js

@@ -0,0 +1,81 @@
+/**
+ * Which permissioned spaces the read in flight is allowed to serve.
+ *
+ * Space records are not public data. A space's authority decides who may read
+ * it, and it decides that one caller at a time — so a row indexed out of a
+ * space carries an audience, and serving it to a request that has not proven
+ * it belongs to that audience discloses private data no matter how the query
+ * was written.
+ *
+ * hatk has no other per-row visibility concept. The takedown join is
+ * viewer-independent and `privateCollections` is all-or-nothing, so neither
+ * could carry this. The rule here is instead:
+ *
+ *   a row with `space IS NULL` is public repo data and always readable;
+ *   a row with a space is readable only inside a scope that names that space.
+ *
+ * The default is an empty scope, which serves no space rows at all. That is
+ * deliberate: a read path nobody remembered to scope fails closed and shows a
+ * member nothing, rather than failing open and showing a stranger everything.
+ * Every query over a record table applies `spaceFilterSql`; the scope is
+ * established per request by whoever established the viewer.
+ */
+import { AsyncLocalStorage } from 'node:async_hooks';
+const EMPTY = new Set();
+/**
+ * Async-local rather than a module global: a server answers requests
+ * concurrently, and one viewer's readable set must never be observable from
+ * another's request while an await is outstanding.
+ */
+const store = new AsyncLocalStorage();
+/**
+ * Run `fn` with exactly these spaces readable.
+ *
+ * Replaces rather than extends any enclosing scope: widening what a nested read
+ * may see is never what a caller means, and a scope that only ever narrows is
+ * one that can be reasoned about locally.
+ */
+export function withReadableSpaces(spaces, fn) {
+    return store.run(new Set(spaces), fn);
+}
+/**
+ * Set the readable spaces for the rest of the current async context.
+ *
+ * `withReadableSpaces` wants a callback, and a request handler is a long body
+ * rather than something to wrap — restructuring it around a closure to hold a
+ * scope would be the tail wagging the dog. A server handler already runs in its
+ * own async context per request, which is the case `enterWith` exists for.
+ */
+export function enterReadableSpaces(spaces) {
+    store.enterWith(new Set(spaces));
+}
+/** The spaces this read may serve. Empty outside any scope. */
+export function readableSpaces() {
+    return store.getStore() ?? EMPTY;
+}
+/** Whether a space would be served to the read in flight. */
+export function isSpaceReadable(space) {
+    if (space == null)
+        return true;
+    return readableSpaces().has(space);
+}
+/**
+ * The space gate as a SQL predicate, for a table aliased `alias` (pass '' for
+ * an unaliased table).
+ *
+ * `startIdx` is the next free `$N` placeholder; the returned `nextIdx` is the
+ * next one after this predicate's own. With nothing readable the predicate
+ * binds no parameters at all, which is the shape almost every request takes.
+ */
+export function spaceFilterSql(alias, startIdx) {
+    const col = alias ? `${alias}.space` : 'space';
+    const spaces = [...readableSpaces()];
+    if (spaces.length === 0)
+        return { sql: `${col} IS NULL`, params: [], nextIdx: startIdx };
+    const placeholders = spaces.map((_, i) => `$${startIdx + i}`).join(', ');
+    return {
+        sql: `(${col} IS NULL OR ${col} IN (${placeholders}))`,
+        params: spaces,
+        nextIdx: startIdx + spaces.length,
+    };
+}

package/dist/templates/feed.tpl

@@ -0,0 +1,18 @@
+import { defineFeed } from '$hatk'
+
+export default defineFeed({
+  collection: 'your.collection.here',
+  label: '{{Name}}',
+
+  async generate(ctx) {
+    // ctx.paginate applies the permissioned-space gate for you, so this page
+    // shows a member the spaces they may read and everyone else the public
+    // rows alone. A feed that builds its own SQL over a space-backed table is
+    // refused with an error naming the table; see ctx.spaceFilter.
+    const { rows, cursor } = await ctx.paginate<{ uri: string }>(
+      `SELECT uri, cid, indexed_at FROM "your.collection.here"`,
+    )
+
+    return ctx.ok({ uris: rows.map((r) => r.uri), cursor })
+  },
+})

package/dist/templates/hook.tpl

@@ -0,0 +1,5 @@
+import { defineHook } from '$hatk'
+
+export default defineHook('{{name}}', async (ctx) => {
+  // Hook logic here
+})

package/dist/templates/label.tpl

@@ -0,0 +1,15 @@
+import { defineLabel } from '$hatk'
+
+export default defineLabel({
+  definition: {
+    identifier: '{{name}}',
+    severity: 'inform',
+    blurs: 'none',
+    defaultSetting: 'warn',
+    locales: [{ lang: 'en', name: '{{Name}}', description: 'Description here' }],
+  },
+  async evaluate(ctx) {
+    // Return array of label identifiers to apply, or empty array
+    return []
+  },
+})

package/dist/templates/og.tpl

@@ -0,0 +1,17 @@
+import type { OpengraphContext, OpengraphResult } from '@hatk/hatk/opengraph'
+
+export default {
+  path: '/og/{{name}}/:id',
+  async generate(ctx: OpengraphContext): Promise<OpengraphResult> {
+    const { db, params } = ctx
+    return {
+      element: {
+        type: 'div',
+        props: {
+          style: { display: 'flex', width: '100%', height: '100%', background: '#080b12', color: 'white', alignItems: 'center', justifyContent: 'center' },
+          children: params.id,
+        },
+      },
+    }
+  },
+}

package/dist/templates/seed.tpl

@@ -0,0 +1,11 @@
+import { seed } from '$hatk'
+
+const { createAccount, createRecord } = seed()
+
+const alice = await createAccount('alice.test')
+
+// await createRecord(alice, 'your.collection.here', {
+//   field: 'value',
+// }, { rkey: 'my-record' })
+
+console.log('\n[seed] Done!')

package/dist/templates/setup.tpl

@@ -0,0 +1,5 @@
+import { defineSetup } from '$hatk'
+
+export default defineSetup(async (ctx) => {
+  // Setup logic here — runs before the server starts
+})

package/dist/templates/test-feed.tpl

@@ -0,0 +1,19 @@
+import { describe, test, expect, beforeAll, afterAll } from 'vitest'
+import { createTestContext } from '@hatk/hatk/test'
+
+let ctx: Awaited<ReturnType<typeof createTestContext>>
+
+beforeAll(async () => {
+  ctx = await createTestContext()
+  await ctx.loadFixtures()
+})
+
+afterAll(async () => ctx?.close())
+
+describe('{{name}} feed', () => {
+  test('returns results', async () => {
+    const feed = ctx.loadFeed('{{name}}')
+    const result = await feed.generate(ctx.feedContext({ limit: 10 }))
+    expect(result).toBeDefined()
+  })
+})

package/dist/templates/test-xrpc.tpl

@@ -0,0 +1,19 @@
+import { describe, test, expect, beforeAll, afterAll } from 'vitest'
+import { createTestContext } from '@hatk/hatk/test'
+
+let ctx: Awaited<ReturnType<typeof createTestContext>>
+
+beforeAll(async () => {
+  ctx = await createTestContext()
+  await ctx.loadFixtures()
+})
+
+afterAll(async () => ctx?.close())
+
+describe('{{name}}', () => {
+  test('returns response', async () => {
+    const handler = ctx.loadXrpc('{{name}}')
+    const result = await handler.handler({ params: {} })
+    expect(result).toBeDefined()
+  })
+})

package/dist/templates/xrpc.tpl

@@ -0,0 +1,53 @@
+import { defineQuery } from '$hatk'
+
+export default defineQuery('{{name}}', async (ctx) => {
+  const { ok, db, params, packCursor, unpackCursor, spaceFilter } = ctx
+  const limit = params.limit ?? 30
+  const cursor = params.cursor
+
+  const conditions: string[] = []
+  const sqlParams: (string | number)[] = []
+  let paramIdx = 1
+
+  // Which permissioned spaces this viewer may be shown. Typed helpers like
+  // ctx.lookup and ctx.getRecords apply this already; hand-written SQL cannot,
+  // because nothing can inject a predicate into a string you wrote. Drop it on
+  // a collection a space writes into and hatk refuses the query by name.
+  //
+  // Outside a viewer's scope it is `s.space IS NULL` and binds nothing, so on an
+  // instance that indexes no space it costs one test on an indexed column.
+  const spaces = spaceFilter('s', paramIdx)
+  conditions.push(spaces.sql)
+  sqlParams.push(...spaces.params)
+  paramIdx = spaces.nextIdx
+
+  if (cursor) {
+    const parsed = unpackCursor(cursor)
+    if (parsed) {
+      conditions.push(`(s.indexed_at < $${paramIdx} OR (s.indexed_at = $${paramIdx + 1} AND s.cid < $${paramIdx + 2}))`)
+      sqlParams.push(parsed.primary, parsed.primary, parsed.cid)
+      paramIdx += 3
+    }
+  }
+
+  const where = conditions.length ? 'WHERE ' + conditions.join(' AND ') : ''
+
+  const rows = (await db.query(
+    `SELECT s.* FROM "your.collection.here" s ${where} ORDER BY s.indexed_at DESC, s.cid DESC LIMIT $${paramIdx}`,
+    sqlParams.concat([limit + 1]),
+  )) as {
+    uri: string
+    cid: string
+    did: string
+    indexed_at: string
+  }[]
+
+  const hasMore = rows.length > limit
+  if (hasMore) rows.pop()
+  const lastRow = rows[rows.length - 1]
+
+  return ok({
+    items: rows,
+    cursor: hasMore && lastRow ? packCursor(lastRow.indexed_at, lastRow.cid) : undefined,
+  })
+})

package/dist/test.d.ts

@@ -4,7 +4,9 @@ import type { FeedContext } from './feeds.ts';
 export interface TestContext {
     db: {
         query: (sql: string, params?: any[]) => Promise<any[]>;
-        run: (sql: string, ...params: any[]) => Promise<void>;
+        run: (sql: string, params?: any[]) => Promise<void>;
+        /** Raw SQL with the permissioned-space guard off, as the runtime contexts have it. */
+        unfiltered: (sql: string, params?: any[]) => Promise<any[]>;
     };
     loadFixtures: (dir?: string) => Promise<void>;
     loadFeed: (name: string) => {

package/dist/test.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../src/test.ts"],"names":[],"mappings":"AAIA,OAAO,EAAc,KAAK,UAAU,EAAE,MAAM,aAAa,CAAA;AAiBzD,OAAO,EAAE,IAAI,IAAI,iBAAiB,EAAE,KAAK,QAAQ,EAAE,MAAM,WAAW,CAAA;AACpE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAE7C,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE;QACF,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,GAAG,EAAE,CAAC,CAAA;QACtD,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,MAAM,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;KACtD,CAAA;IACD,YAAY,EAAE,CAAC,GAAG,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAC7C,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK;QAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,WAAW,KAAK,OAAO,CAAC,GAAG,CAAC,CAAA;KAAE,CAAA;IAC5E,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK;QAAE,OAAO,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,CAAA;KAAE,CAAA;IACnE,WAAW,EAAE,CAAC,IAAI,CAAC,EAAE;QACnB,KAAK,CAAC,EAAE,MAAM,CAAA;QACd,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,MAAM,CAAC,EAAE;YAAE,GAAG,EAAE,MAAM,CAAA;SAAE,GAAG,IAAI,CAAA;QAC/B,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAChC,KAAK,WAAW,CAAA;IACjB,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAC1B,gBAAgB,CAAC,OAAO,EAAE,UAAU,CAAA;IACpC,gBAAgB,CAAC,YAAY,EAAE,MAAM,EAAE,CAAA;CACxC;AAED,MAAM,WAAW,UAAW,SAAQ,WAAW;IAC7C,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAA;IAC9D,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAA;IAC7E,IAAI,EAAE,CAAC,IAAI,CAAC,EAAE,QAAQ,KAAK,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAA;IAC/D,aAAa,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;CAClE;AAYD;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,WAAW,CAAC,CAiL9D;AA8BD,wBAAsB,eAAe,IAAI,OAAO,CAAC,UAAU,CAAC,CAgD3D"}
+{"version":3,"file":"test.d.ts","sourceRoot":"","sources":["../src/test.ts"],"names":[],"mappings":"AAIA,OAAO,EAAc,KAAK,UAAU,EAAE,MAAM,aAAa,CAAA;AAmBzD,OAAO,EAAE,IAAI,IAAI,iBAAiB,EAAE,KAAK,QAAQ,EAAE,MAAM,WAAW,CAAA;AAIpE,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,YAAY,CAAA;AAE7C,MAAM,WAAW,WAAW;IAC1B,EAAE,EAAE;QACF,KAAK,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,GAAG,EAAE,CAAC,CAAA;QACtD,GAAG,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;QACnD,sFAAsF;QACtF,UAAU,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,EAAE,KAAK,OAAO,CAAC,GAAG,EAAE,CAAC,CAAA;KAC5D,CAAA;IACD,YAAY,EAAE,CAAC,GAAG,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;IAC7C,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK;QAAE,QAAQ,EAAE,CAAC,GAAG,EAAE,WAAW,KAAK,OAAO,CAAC,GAAG,CAAC,CAAA;KAAE,CAAA;IAC5E,QAAQ,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK;QAAE,OAAO,EAAE,CAAC,GAAG,EAAE,GAAG,KAAK,OAAO,CAAC,GAAG,CAAC,CAAA;KAAE,CAAA;IACnE,WAAW,EAAE,CAAC,IAAI,CAAC,EAAE;QACnB,KAAK,CAAC,EAAE,MAAM,CAAA;QACd,MAAM,CAAC,EAAE,MAAM,CAAA;QACf,MAAM,CAAC,EAAE;YAAE,GAAG,EAAE,MAAM,CAAA;SAAE,GAAG,IAAI,CAAA;QAC/B,MAAM,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;KAChC,KAAK,WAAW,CAAA;IACjB,KAAK,EAAE,MAAM,OAAO,CAAC,IAAI,CAAC,CAAA;IAC1B,gBAAgB,CAAC,OAAO,EAAE,UAAU,CAAA;IACpC,gBAAgB,CAAC,YAAY,EAAE,MAAM,EAAE,CAAA;CACxC;AAED,MAAM,WAAW,UAAW,SAAQ,WAAW;IAC7C,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,EAAE,CAAC,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAA;IAC9D,OAAO,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,WAAW,KAAK,OAAO,CAAC,QAAQ,CAAC,CAAA;IAC7E,IAAI,EAAE,CAAC,IAAI,CAAC,EAAE,QAAQ,KAAK,UAAU,CAAC,OAAO,iBAAiB,CAAC,CAAA;IAC/D,aAAa,EAAE,CAAC,GAAG,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,MAAM,KAAK,OAAO,CAAC,IAAI,CAAC,CAAA;CAClE;AAYD;;;;;;;;GAQG;AACH,wBAAsB,iBAAiB,IAAI,OAAO,CAAC,WAAW,CAAC,CAyL9D;AA8BD,wBAAsB,eAAe,IAAI,OAAO,CAAC,UAAU,CAAC,CAiD3D"}