@atproto/oauth-scopes 0.0.1 → 0.1.0

package/src/scopes/rpc-permission.test.ts

@@ -0,0 +1,323 @@
+import { RpcPermission } from './rpc-permission.js'
+
+describe('RpcPermission', () => {
+  describe('static', () => {
+    describe('fromString', () => {
+      it('should parse positional scope', () => {
+        const scope = RpcPermission.fromString(
+          'rpc:com.example.service?aud=did:web:example.com%23service_id',
+        )
+        expect(scope).not.toBeNull()
+        expect(scope!.aud).toBe('did:web:example.com#service_id')
+        expect(scope!.lxm).toEqual(['com.example.service'])
+      })
+
+      it('should parse strings correctly', () => {
+        expect(
+          RpcPermission.fromString('rpc?lxm=com.example.method1&aud=*'),
+        ).toEqual({
+          aud: '*',
+          lxm: ['com.example.method1'],
+        })
+        expect(
+          RpcPermission.fromString('rpc:com.example.method1?aud=*'),
+        ).toEqual({
+          aud: '*',
+          lxm: ['com.example.method1'],
+        })
+      })
+
+      it('should render strings correctly', () => {
+        expect(
+          new RpcPermission('did:web:example.com#service_id', [
+            'com.example.service',
+          ]).toString(),
+        ).toBe('rpc:com.example.service?aud=did:web:example.com%23service_id')
+        expect(new RpcPermission('*', ['com.example.method1']).toString()).toBe(
+          'rpc:com.example.method1?aud=*',
+        )
+        expect(
+          new RpcPermission('did:web:example.com#service_id', [
+            'com.example.method1',
+            'com.example.method2',
+          ]).toString(),
+        ).toBe(
+          'rpc?lxm=com.example.method1&lxm=com.example.method2&aud=did:web:example.com%23service_id',
+        )
+      })
+
+      it('should reject scopes without lxm', () => {
+        expect(
+          RpcPermission.fromString('rpc?aud=did:web:example.com%23service_id'),
+        ).toBeNull()
+        expect(
+          RpcPermission.fromString('rpc:?aud=did:web:example.com%23service_id'),
+        ).toBeNull()
+      })
+
+      it('should reject scopes without aud', () => {
+        expect(
+          RpcPermission.fromString('rpc?lxm=com.example.method1'),
+        ).toBeNull()
+        expect(RpcPermission.fromString('rpc:com.example.method1')).toBeNull()
+      })
+
+      it('should reject scopes with lxm in both positional and query form', () => {
+        expect(
+          RpcPermission.fromString(
+            'rpc:com.example.method1?aud=did:web:example.com&lxm=com.example.method2',
+          ),
+        ).toBeNull()
+      })
+
+      it('should parse valid rpc scope with multiple lxm', () => {
+        const scope = RpcPermission.fromString(
+          'rpc?aud=*&lxm=com.example.method1&lxm=com.example.method2',
+        )
+        expect(scope).not.toBeNull()
+        expect(scope!.aud).toBe('*')
+        expect(scope!.lxm).toEqual([
+          'com.example.method1',
+          'com.example.method2',
+        ])
+      })
+
+      it('should reject rpc scope without lxm', () => {
+        const scope = RpcPermission.fromString('rpc?aud=did:web:example.com')
+        expect(scope).toBeNull()
+      })
+
+      it('should reject rpc scope without aud', () => {
+        const scope = RpcPermission.fromString('rpc?lxm=com.example.method1')
+        expect(scope).toBeNull()
+      })
+
+      it('should reject any aud/any lxm', () => {
+        expect(RpcPermission.fromString('rpc?aud=*&lxm=*')).toBeNull()
+        expect(RpcPermission.fromString('rpc:*?aud=*')).toBeNull()
+      })
+
+      it('should reject missing aud', () => {
+        expect(RpcPermission.fromString('rpc:com.example.service')).toBeNull()
+      })
+
+      it('should reject invalid aud', () => {
+        expect(
+          RpcPermission.fromString('rpc:com.example.service?aud=invalid'),
+        ).toBeNull()
+      })
+
+      it('should reject invalid lxm', () => {
+        expect(RpcPermission.fromString('rpc:invalid')).toBeNull()
+        expect(RpcPermission.fromString('rpc?lxm=invalid')).toBeNull()
+      })
+
+      for (const invalid of [
+        'rpc:*',
+        'invalid',
+        'rpc:invalid',
+        'rpc:invalid?aud=did:web:example.com',
+        'rpc:invalid?aud=did:web:example.com%23service_id',
+        'rpc:foo.bar',
+        'rpc:com.example.service?aud=did:web:example.com%23service_id&invalid=param',
+        'rpc:foo.bar.baz?aud=did:web',
+        'rpc:foo.bar.baz?aud=did:web%23service_id',
+        'rpc:foo.bar.baz?aud=did:plc:111',
+        'rpc:foo.bar.baz?aud=did:plc:111%23service_id',
+        'rpc:foo.bar.baz?aud=did:foo:bar',
+        'rpc:foo.bar.baz?aud=did:foo:bar%23service_id',
+        'rpc:foo.bar.baz?aud=did:web:example.com%23service_id&lxm=foo.bar.baz',
+        'rpc:foo.bar.baz?aud=invalid',
+        'rpc:foo.bar.baz?aud=invalid',
+        'rpc:invalid?aud=did:web:example.com',
+        'rpc:invalid?aud=did:web:example.com%23service_id',
+        'rpc:com.example.service?aud=invalid',
+        'notrpc:com.example.service?aud=did:web:example.com%23service_id',
+        'rpc?lxm=invalid&aud=invalid',
+      ]) {
+        it(`should return null for invalid rpc scope: ${invalid}`, () => {
+          expect(RpcPermission.fromString(invalid)).toBeNull()
+        })
+      }
+    })
+
+    describe('scopeNeededFor', () => {
+      it('should return correct scope string for specific lxm and aud', () => {
+        const scope = RpcPermission.scopeNeededFor({
+          lxm: 'com.example.service',
+          aud: 'did:web:example.com#service_id',
+        })
+        expect(scope).toBe(
+          'rpc:com.example.service?aud=did:web:example.com%23service_id',
+        )
+      })
+
+      it('should return scope that accepts all aud with specific lxm', () => {
+        const scope = RpcPermission.scopeNeededFor({
+          lxm: 'com.example.method1',
+          aud: '*',
+        })
+        expect(scope).toBe('rpc:com.example.method1?aud=*')
+      })
+    })
+  })
+
+  describe('instance', () => {
+    describe('matches', () => {
+      it('should match exact lxm and aud', () => {
+        const scope = RpcPermission.fromString(
+          'rpc:com.example.service?aud=did:web:example.com%23service_id',
+        )
+        expect(scope).not.toBeNull()
+        expect(
+          scope!.matches({
+            lxm: 'com.example.service',
+            aud: 'did:web:example.com#service_id',
+          }),
+        ).toBe(true)
+      })
+
+      it('should not match different lxm', () => {
+        const scope = RpcPermission.fromString(
+          'rpc:com.example.service?aud=did:web:example.com%23service_id',
+        )
+        expect(scope).not.toBeNull()
+        expect(
+          scope!.matches({
+            lxm: 'com.example.OtherService',
+            aud: 'did:web:example.com#service_id',
+          }),
+        ).toBe(false)
+      })
+
+      it('should not match different aud', () => {
+        const scope = RpcPermission.fromString(
+          'rpc:com.example.service?aud=did:web:example.com%23service_id',
+        )
+        expect(scope).not.toBeNull()
+        expect(
+          scope!.matches({
+            lxm: 'com.example.service',
+            aud: 'did:example:456#service_id',
+          }),
+        ).toBe(false)
+      })
+
+      it('should match wildcard aud', () => {
+        const scope = RpcPermission.fromString('rpc:com.example.method1?aud=*')
+        expect(scope).not.toBeNull()
+        expect(
+          scope!.matches({
+            lxm: 'com.example.method1',
+            aud: 'did:web:example.com#service_id',
+          }),
+        ).toBe(true)
+      })
+
+      it('should match wildcard lxm', () => {
+        const scope = RpcPermission.fromString(
+          'rpc:*?aud=did:web:example.com%23service_id',
+        )
+        expect(scope).not.toBeNull()
+        expect(
+          scope!.matches({
+            lxm: 'com.example.method1',
+            aud: 'did:web:example.com#service_id',
+          }),
+        ).toBe(true)
+      })
+
+      it('should not match different lxm with wildcard aud', () => {
+        const scope = RpcPermission.fromString(
+          'rpc:*?aud=did:web:example.com%23service_id',
+        )
+        expect(scope).not.toBeNull()
+        expect(
+          scope!.matches({
+            lxm: 'com.example.anyMethod',
+            aud: 'did:web:example.com#service_id',
+          }),
+        ).toBe(true)
+      })
+    })
+
+    describe('toString', () => {
+      it('should format scope with lxm and aud', () => {
+        const scope = new RpcPermission('did:web:example.com#service_id', [
+          'com.example.service',
+        ])
+        expect(scope.toString()).toBe(
+          'rpc:com.example.service?aud=did:web:example.com%23service_id',
+        )
+      })
+
+      it('should format scope with wildcard aud', () => {
+        const scope = new RpcPermission('*', ['com.example.method1'])
+        expect(scope.toString()).toBe('rpc:com.example.method1?aud=*')
+      })
+
+      it('should format scope with wildcard lxm', () => {
+        const scope = new RpcPermission('did:web:example.com#service_id', ['*'])
+        expect(scope.toString()).toBe(
+          'rpc:*?aud=did:web:example.com%23service_id',
+        )
+      })
+
+      it('simplifies lxm if one of them is "*"', () => {
+        const scope = new RpcPermission('did:web:example.com#service_id', [
+          '*',
+          'com.example.method1',
+        ])
+        expect(scope.toString()).toBe(
+          'rpc:*?aud=did:web:example.com%23service_id',
+        )
+      })
+    })
+  })
+
+  describe('consistency', () => {
+    const testCases: { input: string; expected: string }[] = [
+      {
+        input: 'rpc:com.example.service?aud=did:web:example.com%23service_id',
+        expected:
+          'rpc:com.example.service?aud=did:web:example.com%23service_id',
+      },
+      {
+        input: 'rpc:com.example.service?aud=did:web:example.com#service_id',
+        expected:
+          'rpc:com.example.service?aud=did:web:example.com%23service_id',
+      },
+      {
+        input: 'rpc?lxm=com.example.method1&lxm=com.example.method2&aud=*',
+        expected: 'rpc?lxm=com.example.method1&lxm=com.example.method2&aud=*',
+      },
+      {
+        input:
+          'rpc?lxm=com.example.method1&lxm=com.example.method2&lxm=*&aud=did:web:example.com%23service_id',
+        expected: 'rpc:*?aud=did:web:example.com%23service_id',
+      },
+      {
+        input: 'rpc?aud=did:web:example.com%23foo&lxm=com.example.service',
+        expected: 'rpc:com.example.service?aud=did:web:example.com%23foo',
+      },
+      {
+        input: 'rpc?lxm=com.example.method1&aud=did:web:example.com#foo',
+        expected: 'rpc:com.example.method1?aud=did:web:example.com%23foo',
+      },
+      {
+        input: 'rpc?lxm=com.example.method1&aud=did:web:example.com%23bar',
+        expected: 'rpc:com.example.method1?aud=did:web:example.com%23bar',
+      },
+      {
+        input: 'rpc:com.example.method1?&aud=*',
+        expected: 'rpc:com.example.method1?aud=*',
+      },
+    ]
+
+    for (const { input, expected } of testCases) {
+      it(`should properly re-format ${input}`, () => {
+        expect(RpcPermission.fromString(input)?.toString()).toBe(expected)
+      })
+    }
+  })
+})

package/src/scopes/rpc-permission.ts

@@ -0,0 +1,85 @@
+import { AtprotoAudience, isAtprotoAudience } from '@atproto/did'
+import { Nsid, isNsid } from '../lib/nsid.js'
+import { Parser } from '../lib/parser.js'
+import { ResourcePermission } from '../lib/resource-permission.js'
+import { ScopeStringSyntax } from '../lib/syntax-string.js'
+import { NeRoArray, ScopeSyntax, isScopeStringFor } from '../lib/syntax.js'
+
+export { type AtprotoAudience, type Nsid, isAtprotoAudience, isNsid }
+
+export type LxmParam = '*' | Nsid
+export const isLxmParam = (value: unknown): value is LxmParam =>
+  value === '*' || isNsid(value)
+export type AudParam = '*' | AtprotoAudience
+export const isAudParam = (value: unknown): value is AudParam =>
+  value === '*' || isAtprotoAudience(value)
+
+export type RpcPermissionMatch = {
+  lxm: string
+  aud: string
+}
+
+export class RpcPermission
+  implements ResourcePermission<'rpc', RpcPermissionMatch>
+{
+  constructor(
+    public readonly aud: '*' | AtprotoAudience,
+    public readonly lxm: NeRoArray<'*' | Nsid>,
+  ) {}
+
+  matches(options: RpcPermissionMatch) {
+    const { aud, lxm } = this
+    return (
+      (aud === '*' || aud === options.aud) &&
+      (lxm.includes('*') || (lxm as readonly string[]).includes(options.lxm))
+    )
+  }
+
+  toString() {
+    return RpcPermission.parser.format(this)
+  }
+
+  protected static readonly parser = new Parser(
+    'rpc',
+    {
+      lxm: {
+        multiple: true,
+        required: true,
+        validate: isLxmParam,
+        normalize: (value) =>
+          value.length > 1 && value.includes('*')
+            ? (['*'] as const)
+            : ([...new Set(value)].sort() as [Nsid, ...Nsid[]]),
+      },
+      aud: {
+        multiple: false,
+        required: true,
+        validate: isAudParam,
+      },
+    },
+    'lxm',
+  )
+
+  static fromString(scope: string): RpcPermission | null {
+    if (!isScopeStringFor(scope, 'rpc')) return null
+    const syntax = ScopeStringSyntax.fromString(scope)
+    return RpcPermission.fromSyntax(syntax)
+  }
+
+  static fromSyntax(syntax: ScopeSyntax<'rpc'>): RpcPermission | null {
+    const result = RpcPermission.parser.parse(syntax)
+    if (!result) return null
+
+    // rpc:*?aud=* is forbidden
+    if (result.aud === '*' && result.lxm.includes('*')) return null
+
+    return new RpcPermission(result.aud, result.lxm)
+  }
+
+  static scopeNeededFor(options: RpcPermissionMatch): string {
+    return RpcPermission.parser.format({
+      aud: options.aud as AtprotoAudience,
+      lxm: [options.lxm as Nsid],
+    })
+  }
+}

package/src/scopes-set.test.ts

@@ -22,19 +22,19 @@ describe('ScopesSet', () => {
   })
 
   it('should match included scopes', () => {
-    const set = new ScopesSet(['repo:foo.bar'])
+    const set = new ScopesSet(['repo:com.example.foo'])
     expect(
-      set.matches('repo', { action: 'create', collection: 'foo.bar' }),
+      set.matches('repo', { action: 'create', collection: 'com.example.foo' }),
     ).toBe(true)
     expect(
-      set.matches('repo', { action: 'create', collection: 'baz.qux' }),
+      set.matches('repo', { action: 'create', collection: 'com.example.bar' }),
     ).toBe(false)
   })
 
   it('should not match missing scopes', () => {
-    const set = new ScopesSet(['repo:foo.bar?action=create'])
+    const set = new ScopesSet(['repo:com.example.foo?action=create'])
     expect(
-      set.matches('repo', { action: 'delete', collection: 'foo.bar' }),
+      set.matches('repo', { action: 'delete', collection: 'com.example.foo' }),
     ).toBe(false)
   })
 

package/src/scopes-set.ts

@@ -1,12 +1,32 @@
 import { ScopeMissingError } from './scope-missing-error.js'
 import {
-  ScopeMatchingOptionsByResource,
-  scopeMatches,
-  scopeNeededFor,
-} from './utilities.js'
+  AccountPermission,
+  AccountPermissionMatch,
+} from './scopes/account-permission.js'
+import {
+  BlobPermission,
+  BlobPermissionMatch,
+} from './scopes/blob-permission.js'
+import {
+  IdentityPermission,
+  IdentityPermissionMatch,
+} from './scopes/identity-permission.js'
+import {
+  RepoPermission,
+  RepoPermissionMatch,
+} from './scopes/repo-permission.js'
+import { RpcPermission, RpcPermissionMatch } from './scopes/rpc-permission.js'
 
 export { ScopeMissingError }
 
+export type ScopeMatchingOptionsByResource = {
+  account: AccountPermissionMatch
+  identity: IdentityPermissionMatch
+  repo: RepoPermissionMatch
+  rpc: RpcPermissionMatch
+  blob: BlobPermissionMatch
+}
+
 /**
  * Utility class to manage a set of scopes and check if they match specific
  * options for a given resource.
@@ -21,7 +41,7 @@ export class ScopesSet extends Set<string> {
     options: ScopeMatchingOptionsByResource[R],
   ): boolean {
     for (const scope of this) {
-      if (scopeMatches(scope, resource, options)) return true
+      if (permissionScopeMatches(scope, resource, options)) return true
     }
     return false
   }
@@ -58,3 +78,57 @@ export class ScopesSet extends Set<string> {
     return new ScopesSet(string?.split(' '))
   }
 }
+
+function scopeNeededFor<R extends keyof ScopeMatchingOptionsByResource>(
+  resource: R,
+  options: ScopeMatchingOptionsByResource[R],
+): string {
+  switch (resource) {
+    case 'account':
+      return AccountPermission.scopeNeededFor(options as AccountPermissionMatch)
+    case 'identity':
+      return IdentityPermission.scopeNeededFor(
+        options as IdentityPermissionMatch,
+      )
+    case 'repo':
+      return RepoPermission.scopeNeededFor(options as RepoPermissionMatch)
+    case 'rpc':
+      return RpcPermission.scopeNeededFor(options as RpcPermissionMatch)
+    case 'blob':
+      return BlobPermission.scopeNeededFor(options as BlobPermissionMatch)
+  }
+  // @ts-expect-error
+  throw new TypeError(`Unknown resource: ${resource}`)
+}
+
+function permissionScopeMatches<R extends keyof ScopeMatchingOptionsByResource>(
+  scope: string,
+  resource: R,
+  options: ScopeMatchingOptionsByResource[R],
+): boolean {
+  // @NOTE we might want to cache the parsed scopes though, in practice, a
+  // single scope is unlikely to be parsed multiple times during a single
+  // request.
+  const permission = parsePermissionScope(resource, scope)
+  if (!permission) return false
+
+  // @ts-expect-error
+  return permission.matches(options)
+}
+
+function parsePermissionScope(resource: string, scope: string) {
+  switch (resource) {
+    case 'account':
+      return AccountPermission.fromString(scope)
+    case 'identity':
+      return IdentityPermission.fromString(scope)
+    case 'repo':
+      return RepoPermission.fromString(scope)
+    case 'rpc':
+      return RpcPermission.fromString(scope)
+    case 'blob':
+      return BlobPermission.fromString(scope)
+    default:
+      return null
+  }
+}

package/tsconfig.build.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/index.ts","./src/parser.ts","./src/permission-set-transition.ts","./src/permission-set.ts","./src/scope-missing-error.ts","./src/scopes-set.ts","./src/syntax.ts","./src/utilities.ts","./src/lib/did.ts","./src/lib/mime.ts","./src/lib/nsid.ts","./src/lib/util.ts","./src/resources/account-scope.ts","./src/resources/blob-scope.ts","./src/resources/identity-scope.ts","./src/resources/repo-scope.ts","./src/resources/rpc-scope.ts"],"version":"5.8.3"}
+{"root":["./src/atproto-oauth-scope.ts","./src/index.ts","./src/scope-missing-error.ts","./src/scope-permissions-transition.ts","./src/scope-permissions.ts","./src/scopes-set.ts","./src/lib/lexicon.ts","./src/lib/mime.ts","./src/lib/nsid.ts","./src/lib/parser.ts","./src/lib/resource-permission.ts","./src/lib/syntax-lexicon.ts","./src/lib/syntax-string.ts","./src/lib/syntax.ts","./src/lib/util.ts","./src/scopes/account-permission.ts","./src/scopes/blob-permission.ts","./src/scopes/identity-permission.ts","./src/scopes/include-scope.ts","./src/scopes/repo-permission.ts","./src/scopes/rpc-permission.ts"],"version":"5.8.3"}

package/tsconfig.tests.tsbuildinfo

@@ -1 +1 @@
-{"root":["./src/index.ts","./src/parser.ts","./src/permission-set-transition.test.ts","./src/permission-set-transition.ts","./src/permission-set.test.ts","./src/permission-set.ts","./src/scope-missing-error.ts","./src/scopes-set.test.ts","./src/scopes-set.ts","./src/syntax.test.ts","./src/syntax.ts","./src/utilities.ts","./src/lib/did.ts","./src/lib/mime.test.ts","./src/lib/mime.ts","./src/lib/nsid.ts","./src/lib/util.ts","./src/resources/account-scope.test.ts","./src/resources/account-scope.ts","./src/resources/blob-scope.test.ts","./src/resources/blob-scope.ts","./src/resources/identity-scope.test.ts","./src/resources/identity-scope.ts","./src/resources/repo-scope.test.ts","./src/resources/repo-scope.ts","./src/resources/rpc-scope.test.ts","./src/resources/rpc-scope.ts"],"version":"5.8.3"}
+{"root":["./src/atproto-oauth-scope.ts","./src/index.ts","./src/scope-missing-error.ts","./src/scope-permissions-transition.test.ts","./src/scope-permissions-transition.ts","./src/scope-permissions.test.ts","./src/scope-permissions.ts","./src/scopes-set.test.ts","./src/scopes-set.ts","./src/lib/lexicon.ts","./src/lib/mime.test.ts","./src/lib/mime.ts","./src/lib/nsid.ts","./src/lib/parser.ts","./src/lib/resource-permission.ts","./src/lib/syntax-lexicon.ts","./src/lib/syntax-string.test.ts","./src/lib/syntax-string.ts","./src/lib/syntax.test.ts","./src/lib/syntax.ts","./src/lib/util.ts","./src/scopes/account-permission.test.ts","./src/scopes/account-permission.ts","./src/scopes/blob-permission.test.ts","./src/scopes/blob-permission.ts","./src/scopes/identity-permission.test.ts","./src/scopes/identity-permission.ts","./src/scopes/include-scope.test.ts","./src/scopes/include-scope.ts","./src/scopes/repo-permission.test.ts","./src/scopes/repo-permission.ts","./src/scopes/rpc-permission.test.ts","./src/scopes/rpc-permission.ts"],"version":"5.8.3"}

package/dist/lib/did.d.ts

@@ -1,3 +0,0 @@
-export type DIDLike = `did:${string}`;
-export declare const isDIDLike: (value: string) => value is DIDLike;
-//# sourceMappingURL=did.d.ts.map

package/dist/lib/did.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"did.d.ts","sourceRoot":"","sources":["../../src/lib/did.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,GAAG,OAAO,MAAM,EAAE,CAAA;AACrC,eAAO,MAAM,SAAS,GAAI,OAAO,MAAM,KAAG,KAAK,IAAI,OACzB,CAAA"}

package/dist/lib/did.js

@@ -1,6 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.isDIDLike = void 0;
-const isDIDLike = (value) => value.startsWith('did:');
-exports.isDIDLike = isDIDLike;
-//# sourceMappingURL=did.js.map

package/dist/lib/did.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"did.js","sourceRoot":"","sources":["../../src/lib/did.ts"],"names":[],"mappings":";;;AACO,MAAM,SAAS,GAAG,CAAC,KAAa,EAAoB,EAAE,CAC3D,KAAK,CAAC,UAAU,CAAC,MAAM,CAAC,CAAA;AADb,QAAA,SAAS,aACI"}

package/dist/parser.d.ts

@@ -1,31 +0,0 @@
-import { NeRoArray, ResourceSyntax, ScopeForResource } from './syntax.js';
-type InferStringPredicate<T extends undefined | ((value: string) => boolean)> = T extends ((value: string) => value is infer U extends string) ? U : string;
-type ParamsSchema = Record<string, {
-    multiple: false;
-    required: boolean;
-    default?: string;
-    normalize?: (value: string) => string;
-    validate?: (value: string) => boolean;
-} | {
-    multiple: true;
-    required: boolean;
-    default?: NeRoArray<string>;
-    normalize?: (value: NeRoArray<string>) => NeRoArray<string>;
-    validate?: (value: string) => boolean;
-}>;
-type ParsedParams<S extends ParamsSchema> = {
-    [K in keyof S]: (S[K]['required'] extends true ? never : 'default' extends keyof S[K] ? S[K]['default'] : undefined) | (S[K]['multiple'] extends true ? NeRoArray<InferStringPredicate<S[K]['validate']>> : InferStringPredicate<S[K]['validate']>);
-} & NonNullable<unknown>;
-export declare class Parser<R extends string, S extends ParamsSchema> {
-    readonly resource: R;
-    readonly schema: S;
-    readonly positionalName?: (keyof S & string) | undefined;
-    readonly schemaKeys: ReadonlyArray<keyof S & string>;
-    constructor(resource: R, schema: S, positionalName?: (keyof S & string) | undefined);
-    format(values: ParsedParams<S>): ScopeForResource<R>;
-    parse(syntax: ResourceSyntax): { [K in keyof S]: (S[K]["required"] extends true ? never : "default" extends keyof S[K] ? S[K][keyof S[K] & "default"] : undefined) | (S[K]["multiple"] extends true ? NeRoArray<InferStringPredicate<S[K]["validate"]>> : InferStringPredicate<S[K]["validate"]>); } | null;
-    parseString(scope: string): ParsedParams<S> | null;
-}
-export declare function knownValuesValidator<T extends string>(values: Iterable<T>): (value: string) => value is T;
-export {};
-//# sourceMappingURL=parser.d.ts.map

package/dist/parser.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"parser.d.ts","sourceRoot":"","sources":["../src/parser.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,SAAS,EACT,cAAc,EACd,gBAAgB,EAEjB,MAAM,aAAa,CAAA;AAEpB,KAAK,oBAAoB,CAAC,CAAC,SAAS,SAAS,GAAG,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAC,IAC1E,CAAC,SAAS,CAAC,CAAC,KAAK,EAAE,MAAM,KAAK,KAAK,IAAI,MAAM,CAAC,SAAS,MAAM,CAAC,GAAG,CAAC,GAAG,MAAM,CAAA;AAE7E,KAAK,YAAY,GAAG,MAAM,CACxB,MAAM,EACJ;IACE,QAAQ,EAAE,KAAK,CAAA;IACf,QAAQ,EAAE,OAAO,CAAA;IACjB,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,MAAM,CAAA;IACrC,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAA;CACtC,GACD;IACE,QAAQ,EAAE,IAAI,CAAA;IACd,QAAQ,EAAE,OAAO,CAAA;IACjB,OAAO,CAAC,EAAE,SAAS,CAAC,MAAM,CAAC,CAAA;IAC3B,SAAS,CAAC,EAAE,CAAC,KAAK,EAAE,SAAS,CAAC,MAAM,CAAC,KAAK,SAAS,CAAC,MAAM,CAAC,CAAA;IAC3D,QAAQ,CAAC,EAAE,CAAC,KAAK,EAAE,MAAM,KAAK,OAAO,CAAA;CACtC,CACJ,CAAA;AAED,KAAK,YAAY,CAAC,CAAC,SAAS,YAAY,IAAI;KACzC,CAAC,IAAI,MAAM,CAAC,GACT,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,SAAS,IAAI,GAC1B,KAAK,GACL,SAAS,SAAS,MAAM,CAAC,CAAC,CAAC,CAAC,GAC1B,CAAC,CAAC,CAAC,CAAC,CAAC,SAAS,CAAC,GACf,SAAS,CAAC,GAChB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,SAAS,IAAI,GAC1B,SAAS,CAAC,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC,GACjD,oBAAoB,CAAC,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC;CAChD,GAAG,WAAW,CAAC,OAAO,CAAC,CAAA;AAExB,qBAAa,MAAM,CAAC,CAAC,SAAS,MAAM,EAAE,CAAC,SAAS,YAAY;IAIxD,QAAQ,CAAC,QAAQ,EAAE,CAAC;IACpB,QAAQ,CAAC,MAAM,EAAE,CAAC;IAClB,QAAQ,CAAC,cAAc,CAAC,GAAE,MAAM,CAAC,GAAG,MAAM;IAL5C,QAAQ,CAAC,UAAU,EAAE,aAAa,CAAC,MAAM,CAAC,GAAG,MAAM,CAAC,CAAA;gBAGzC,QAAQ,EAAE,CAAC,EACX,MAAM,EAAE,CAAC,EACT,cAAc,CAAC,GAAE,MAAM,CAAC,GAAG,MAAM,aAAA;IAK5C,MAAM,CAAC,MAAM,EAAE,YAAY,CAAC,CAAC,CAAC,GAAG,gBAAgB,CAAC,CAAC,CAAC;IAuCpD,KAAK,CAAC,MAAM,EAAE,cAAc,MA7D3B,CAAC;IAgGF,WAAW,CAAC,KAAK,EAAE,MAAM,GAAG,YAAY,CAAC,CAAC,CAAC,GAAG,IAAI;CAInD;AAiBD,wBAAgB,oBAAoB,CAAC,CAAC,SAAS,MAAM,EAAE,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC,IAEhE,OAAO,MAAM,KAAG,KAAK,IAAI,CAAC,CACnC"}