@dxos/keys 0.8.4-staging.ac66bdf99f → 0.9.0

package/src/entity-id.ts

@@ -0,0 +1,202 @@
+//
+// Copyright 2025 DXOS.org
+//
+
+import * as Schema from 'effect/Schema';
+import { type PRNG, type ULIDFactory, monotonicFactory } from 'ulidx';
+
+// Crockford Base32 alphabet used by ULID. Excludes I, L, O, U.
+const ALPHABET = '0123456789ABCDEFGHJKMNPQRSTVWXYZ';
+
+// TODO(dmaretskyi): Make brand.
+// export const EntityIdBrand: unique symbol = Symbol('@dxos/echo/EntityId');
+// export const EntityIdSchema = Schema.ULID.pipe(S.brand(EntityIdBrand));
+const EntityIdSchema = Schema.String.pipe(Schema.pattern(/^[0-7][0-9A-HJKMNP-TV-Z]{25}$/i)).annotations({
+  description: 'A Universally Unique Lexicographically Sortable Identifier',
+  pattern: '^[0-7][0-9A-HJKMNP-TV-Z]{25}$',
+});
+
+export type EntityId = typeof EntityIdSchema.Type;
+
+export interface EntityIdClass extends Schema.SchemaClass<EntityId, string> {
+  /**
+   * @returns true if the string is a valid EntityId.
+   */
+  isValid(id: string): id is EntityId;
+
+  /**
+   * Creates an EntityId from a string validating the format.
+   */
+  make(id: string): EntityId;
+
+  /**
+   * Generates a random EntityId.
+   */
+  random(): EntityId;
+
+  /**
+   * Derives a deterministic ULID-format EntityId from arbitrary seed values.
+   *
+   * The same inputs always produce the same id, across processes, isolates, and workers.
+   * Unlike `random()`, this method does not call `crypto.getRandomValues()` and is therefore
+   * safe to call at module top-level — required for Cloudflare workerd, which forbids random
+   * generation in global scope.
+   *
+   * Intended for stable identity of declarative artefacts (e.g. `Type.Type` entities derived
+   * from a `(typename, version)` pair, fixtures, well-known objects). NOT a substitute for
+   * `random()` when global uniqueness is required: callers must guarantee seed uniqueness
+   * themselves; identical seeds yield identical ids and therefore collide.
+   *
+   * The result always passes `EntityId.isValid(...)`.
+   *
+   * @param seed - One or more seed values; coerced to strings and joined.
+   *
+   * ```ts
+   * EntityId.deterministic('org.dxos.type.person', '0.1.0'); // stable across runs
+   * ```
+   */
+  deterministic(...seed: (string | number)[]): EntityId;
+
+  /**
+   * WARNING: To be used only within tests.
+   *
+   * Disables randomness in EntityId generation, causing the same sequence of IDs to be generated.
+   * Do not use in production code as this will cause data collisions.
+   * Place this at the top of the test file to ensure that the same sequence of IDs is generated.
+   *
+   * ```ts
+   * EntityId.dangerouslyDisableRandomness();
+   *
+   * describe('suite', () => {
+   *   // ...
+   * });
+   * ```
+   *
+   * NOTE: The generated IDs depend on the order of EntityId.random() calls, which might be affected by test order, scheduling, etc.
+   */
+  dangerouslyDisableRandomness(): void;
+
+  /**
+   * WARNING: To be used only within tests.
+   *
+   * Pins the time component of generated EntityIds and seeds the PRNG used for the random component,
+   * causing the same sequence of IDs to be generated across runs.
+   * Do not use in production code as this will cause data collisions.
+   *
+   * @param time - Fixed timestamp (ms since epoch) used as the ULID time component.
+   * @param seed - Seed value for the PRNG used for the ULID random component.
+   *
+   * ```ts
+   * EntityId.dangerouslySetSeed(new Date('2025-01-01').getTime(), 42);
+   * ```
+   *
+   * NOTE: The generated IDs depend on the order of EntityId.random() calls, which might be affected by test order, scheduling, etc.
+   */
+  dangerouslySetSeed(time: number, seed: number): void;
+}
+
+/**
+ * Randomly generated unique identifier for an object.
+ *
+ * Follows ULID spec.
+ */
+export const EntityId: EntityIdClass = class extends EntityIdSchema {
+  static #factory: ULIDFactory = monotonicFactory();
+  static #seedTime: number | undefined = undefined;
+
+  static isValid(id: string): id is EntityId {
+    try {
+      Schema.decodeSync(EntityId)(id);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  static random(): EntityId {
+    return this.#factory(this.#seedTime) as EntityId;
+  }
+
+  static deterministic(...seed: (string | number)[]): EntityId {
+    const input = seed.map((value) => String(value)).join('\0');
+    // FNV-1a 32-bit ×2 → 64 bits of derived entropy, packed into the 80-bit ULID random component.
+    let h1 = 0x811c9dc5 >>> 0;
+    let h2 = 0x1b873593 >>> 0;
+    for (let i = 0; i < input.length; i++) {
+      const code = input.charCodeAt(i);
+      h1 = Math.imul(h1 ^ code, 0x01000193) >>> 0;
+      h2 = Math.imul(h2 ^ ((code << 13) | (code >>> 3)), 0x01000193) >>> 0;
+    }
+    // 10 chars for the time component, all '0' — pins to the ULID epoch (timestamp 0) so the leading
+    // char is in [0-7]. The randomness lives entirely in the 16-char random component below.
+    const time = ALPHABET[0].repeat(10);
+    let bits = (BigInt(h1) << 32n) | BigInt(h2);
+    let rand = '';
+    for (let i = 0; i < 16; i++) {
+      rand = ALPHABET[Number(bits & 0x1fn)] + rand;
+      bits >>= 5n;
+    }
+    return (time + rand) as EntityId;
+  }
+
+  static dangerouslyDisableRandomness() {
+    this.#factory = monotonicFactory(makeTestPRNG());
+    this.#seedTime = new Date('2025-01-01').getTime();
+  }
+
+  static dangerouslySetSeed(time: number, seed: number) {
+    this.#factory = monotonicFactory(makeTestPRNG(seed));
+    this.#seedTime = time;
+  }
+};
+
+/**
+ * Test PRNG that always starts with the same seed and produces the same sequence.
+ */
+const makeTestPRNG = (seed: number = 0): PRNG => {
+  const rng = new SimplePRNG(seed);
+  return () => {
+    return rng.next();
+  };
+};
+
+/**
+ * Simple Linear Congruential Generator (LCG) for pseudo-random number generation.
+ * Returns numbers in the range [0, 1) (0 inclusive, 1 exclusive).
+ */
+export class SimplePRNG {
+  #seed: number;
+
+  // LCG parameters (from Numerical Recipes)
+  static readonly #a = 1664525;
+  static readonly #c = 1013904223;
+  static readonly #m = Math.pow(2, 32);
+
+  /**
+   * Creates a new PRNG instance.
+   * @param seed - Initial seed value. If not provided, uses 0.
+   */
+  constructor(seed: number = 0) {
+    this.#seed = seed;
+  }
+
+  /**
+   * Generates the next pseudo-random number in the range [0, 1).
+   * @returns A pseudo-random number between 0 (inclusive) and 1 (exclusive).
+   */
+  next(): number {
+    // Update seed using LCG formula: (a * seed + c) mod m
+    this.#seed = (SimplePRNG.#a * this.#seed + SimplePRNG.#c) % SimplePRNG.#m;
+
+    // Normalize to [0, 1) range
+    return this.#seed / SimplePRNG.#m;
+  }
+
+  /**
+   * Resets the generator with a new seed.
+   * @param seed - New seed value.
+   */
+  reset(seed: number): void {
+    this.#seed = seed;
+  }
+}

package/src/identity-did.test.ts

@@ -2,11 +2,13 @@
 // Copyright 2024 DXOS.org
 //
 
-import { expect, test } from 'vitest';
+import * as JSONSchema from 'effect/JSONSchema';
+import * as Schema from 'effect/Schema';
+import { test } from 'vitest';
 
 import { IdentityDid } from './identity-did';
 
-test('identity-did', () => {
+test('identity-did', ({ expect }) => {
   const id = IdentityDid.random();
 
   expect(id.length).toBe(42);
@@ -15,3 +17,18 @@ test('identity-did', () => {
   expect(decoded.length).toBe(IdentityDid.byteLength);
   expect(IdentityDid.encode(decoded)).toBe(id);
 });
+
+test('identity-did schema', ({ expect }) => {
+  const id = IdentityDid.random();
+
+  // Validates and brands a plain string.
+  expect(IdentityDid.make(id)).toBe(id);
+  expect(Schema.is(IdentityDid)(id)).toBe(true);
+  expect(Schema.is(IdentityDid)('not-a-did')).toBe(false);
+
+  // Rejects a correctly-prefixed, correctly-sized string that is not valid base-32.
+  expect(IdentityDid.isValid(`did:halo:B${'1'.repeat(32)}`)).toBe(false);
+
+  // Serializes to JSON Schema (a plain string type), unlike Schema.instanceOf.
+  expect(() => JSONSchema.make(IdentityDid)).not.toThrow();
+});

package/src/identity-did.ts

@@ -4,11 +4,50 @@
 
 import base32Decode from 'base32-decode';
 import base32Encode from 'base32-encode';
+import * as Schema from 'effect/Schema';
 
 import { invariant } from '@dxos/invariant';
 
 import { randomBytes } from './random-bytes';
 
+/**
+ * Denotes RFC4648 base-32 format.
+ */
+const MULTIBASE_PREFIX = 'B';
+
+const DID_PREFIX = 'did:halo:';
+
+const DECODED_BYTE_LENGTH = 20;
+
+const ENCODED_LENGTH = 42;
+
+/**
+ * RFC4648 base-32 alphabet (uppercase A–Z and digits 2–7).
+ */
+const RFC4648_BASE32_PATTERN = /^[A-Z2-7]+$/;
+
+const isValid = (value: unknown): value is IdentityDid => {
+  if (
+    typeof value !== 'string' ||
+    !value.startsWith(DID_PREFIX + MULTIBASE_PREFIX) ||
+    value.length !== ENCODED_LENGTH
+  ) {
+    return false;
+  }
+
+  const encoded = value.slice(DID_PREFIX.length + MULTIBASE_PREFIX.length);
+  if (!RFC4648_BASE32_PATTERN.test(encoded)) {
+    return false;
+  }
+
+  try {
+    // Reject inputs that pass the prefix/length check but are not decodable to the expected byte length.
+    return base32Decode(encoded, 'RFC4648').byteLength === DECODED_BYTE_LENGTH;
+  } catch {
+    return false;
+  }
+};
+
 /**
  * A unique identifier for an identity.
  * Identity DIDs are generated by creating a keypair, and then taking the first 20 bytes of the SHA-256 hash of the public key and encoding them to multibase RFC4648 base-32 format (prefixed with B, see Multibase Table).
@@ -16,34 +55,30 @@ import { randomBytes } from './random-bytes';
  */
 export type IdentityDid = string & { __IdentityDid: never };
 
-export const IdentityDid = Object.freeze({
-  byteLength: 20,
-  encode: (value: Uint8Array): IdentityDid => {
+export const IdentityDid: Schema.Schema<IdentityDid, string> & {
+  byteLength: number;
+  encode: (value: Uint8Array) => IdentityDid;
+  decode: (value: IdentityDid) => Uint8Array;
+  isValid: (value: unknown) => value is IdentityDid;
+  make: (value: string) => IdentityDid;
+  random: () => IdentityDid;
+} = class extends Schema.String.pipe(Schema.filter(isValid)) {
+  static byteLength = DECODED_BYTE_LENGTH;
+
+  static encode = (value: Uint8Array): IdentityDid => {
     invariant(value instanceof Uint8Array, 'Invalid type');
     invariant(value.length === IdentityDid.byteLength, 'Invalid length');
-
     return (DID_PREFIX + MULTIBASE_PREFIX + base32Encode(value, 'RFC4648')) as IdentityDid;
-  },
-  decode: (value: IdentityDid): Uint8Array => {
-    invariant(value.startsWith(DID_PREFIX + MULTIBASE_PREFIX), 'Invalid multibase32 encoding');
+  };
 
-    return new Uint8Array(base32Decode(value.slice(10), 'RFC4648'));
-  },
-  isValid: (value: string): value is IdentityDid => {
-    return (
-      typeof value === 'string' && value.startsWith(DID_PREFIX + MULTIBASE_PREFIX) && value.length === ENCODED_LENGTH
-    );
-  },
-  random: (): IdentityDid => {
-    return IdentityDid.encode(randomBytes(IdentityDid.byteLength));
-  },
-});
-
-/**
- * Denotes RFC4648 base-32 format.
- */
-const MULTIBASE_PREFIX = 'B';
+  static decode = (value: IdentityDid): Uint8Array => {
+    invariant(value.startsWith(DID_PREFIX + MULTIBASE_PREFIX), 'Invalid multibase32 encoding');
+    return new Uint8Array(base32Decode(value.slice(DID_PREFIX.length + MULTIBASE_PREFIX.length), 'RFC4648'));
+  };
 
-const DID_PREFIX = 'did:halo:';
+  static isValid = isValid;
 
-const ENCODED_LENGTH = 42;
+  static random = (): IdentityDid => {
+    return IdentityDid.encode(randomBytes(IdentityDid.byteLength));
+  };
+};

package/src/index.ts

@@ -2,9 +2,13 @@
 // Copyright 2020 DXOS.org
 //
 
-export * from './dxn';
+export * as DXN from './DXN';
+export * as EID from './EID';
+export * as URI from './URI';
+
 export * from './identity-did';
-export * from './object-id';
+export * from './entity-id';
+export * from './parse-id';
 export * from './public-key';
 export * from './space-id';
 export type * from './types';

package/src/parse-id.test.ts

@@ -0,0 +1,32 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { describe, expect, test } from 'vitest';
+
+import { parseId } from './parse-id';
+
+describe('parseId', () => {
+  test('space id', () => {
+    const id = '123456789012345678901234567890123';
+    expect(parseId(id)).toEqual({ spaceId: id });
+  });
+
+  test('object id', () => {
+    const id = '12345678901234567890123456';
+    expect(parseId(id)).toEqual({ objectId: id });
+  });
+
+  test('fully qualified id', () => {
+    const id = '123456789012345678901234567890123:12345678901234567890123456';
+    expect(parseId(id)).toEqual({
+      spaceId: '123456789012345678901234567890123',
+      objectId: '12345678901234567890123456',
+    });
+  });
+
+  test('invalid id', () => {
+    const id = '123456789012345678901234561234567890123456';
+    expect(parseId(id)).toEqual({});
+  });
+});

package/src/parse-id.ts

@@ -0,0 +1,32 @@
+//
+// Copyright 2024 DXOS.org
+//
+
+import { type EntityId } from './entity-id';
+import { type SpaceId } from './space-id';
+
+export const SPACE_ID_LENGTH = 33;
+export const OBJECT_ID_LENGTH = 26;
+export const FQ_ID_LENGTH = SPACE_ID_LENGTH + OBJECT_ID_LENGTH + 1;
+
+export const parseId = (id?: string): { spaceId?: SpaceId; objectId?: EntityId } => {
+  if (!id) {
+    return {};
+  } else if (id.length === SPACE_ID_LENGTH) {
+    return {
+      spaceId: id as SpaceId,
+    };
+  } else if (id.length === OBJECT_ID_LENGTH) {
+    return {
+      objectId: id as EntityId,
+    };
+  } else if (id.length === FQ_ID_LENGTH && id.indexOf(':') === SPACE_ID_LENGTH) {
+    const [spaceId, objectId] = id.split(':');
+    return {
+      spaceId: spaceId as SpaceId,
+      objectId: objectId as EntityId,
+    };
+  } else {
+    return {};
+  }
+};

package/src/public-key.ts

@@ -14,7 +14,7 @@ import {
   inspectCustom,
   truncateKey,
 } from '@dxos/debug';
-import { invariant } from '@dxos/invariant';
+import { assertArgument, invariant } from '@dxos/invariant';
 
 import { randomBytes } from './random-bytes';
 
@@ -149,7 +149,7 @@ export class PublicKey implements Equatable {
    * @deprecated All keys should be represented as instances of PublicKey.
    */
   static bufferize(str: string): Buffer {
-    invariant(typeof str === 'string', 'Invalid type');
+    assertArgument(typeof str === 'string', 'str', 'Invalid type');
     const buffer = Buffer.from(str, 'hex');
     // invariant(buffer.length === PUBLIC_KEY_LENGTH || buffer.length === SECRET_KEY_LENGTH,
     //   `Invalid key length: ${buffer.length}`);
@@ -216,7 +216,7 @@ export class PublicKey implements Equatable {
     return 'B' + base32Encode(this._value, 'RFC4648');
   }
 
-  truncate(length = undefined): string {
+  truncate(length?: number): string {
     return truncateKey(this, length);
   }
 

package/dist/types/src/dxn.d.ts

@@ -1,129 +0,0 @@
-import * as Schema from 'effect/Schema';
-import type { InspectOptionsStylized, inspect } from 'node:util';
-import { type DevtoolsFormatter, devtoolsFormatter, inspectCustom } from '@dxos/debug';
-import { ObjectId } from './object-id';
-import { SpaceId } from './space-id';
-/**
- * Tags for ECHO DXNs that should resolve the object ID in the local space.
- */
-export declare const LOCAL_SPACE_TAG = "@";
-export declare const DXN_ECHO_REGEXP: RegExp;
-export declare const QueueSubspaceTags: Readonly<{
-    DATA: "data";
-    TRACE: "trace";
-}>;
-export type QueueSubspaceTag = (typeof QueueSubspaceTags)[keyof typeof QueueSubspaceTags];
-/**
- * DXN unambiguously names a resource like an ECHO object, schema definition, plugin, etc.
- * Each DXN starts with a dxn prefix, followed by a resource kind.
- * Colon Symbol : is used a delimiter between parts.
- * DXNs may contain slashes.
- * '@' in the place of the space id is used to denote that the DXN should be resolved in the local space.
- *
- * @example
- * ```
- * dxn:echo:<space key>:<echo id>
- * dxn:echo:BA25QRC2FEWCSAMRP4RZL65LWJ7352CKE:01J00J9B45YHYSGZQTQMSKMGJ6
- * dxn:echo:@:01J00J9B45YHYSGZQTQMSKMGJ6
- * dxn:type:org.dxos.type.calendar
- * dxn:plugin:org.dxos.agent.plugin.functions
- * ```
- */
-export declare class DXN {
-    #private;
-    static Schema: Schema.refine<string, typeof Schema.NonEmptyString>;
-    static hash(dxn: DXN): string;
-    /**
-     * Kind constants.
-     */
-    static kind: Readonly<{
-        /**
-         * dxn:type:<type_name>[:<version>]
-         */
-        TYPE: "type";
-        /**
-         * dxn:echo:<space_id>:<echo_id>
-         * dxn:echo:@:<echo_id>
-         */
-        ECHO: "echo";
-        /**
-         * The subspace tag enables us to partition queues by usage within the context of a space.
-         * dxn:queue:<subspace_tag>:<space_id>:<queue_id>[:object_id]
-         * dxn:queue:data:BA25QRC2FEWCSAMRP4RZL65LWJ7352CKE:01J00J9B45YHYSGZQTQMSKMGJ6
-         * dxn:queue:trace:BA25QRC2FEWCSAMRP4RZL65LWJ7352CKE:01J00J9B45YHYSGZQTQMSKMGJ6
-         */
-        QUEUE: "queue";
-    }>;
-    /**
-     * Exactly equals.
-     */
-    static equals(a: DXN, b: DXN): boolean;
-    static equalsEchoId(a: DXN, b: DXN): boolean;
-    static isDXNString(dxn: string): boolean;
-    static parse(dxn: string): DXN;
-    static tryParse(dxn: string): DXN | undefined;
-    /**
-     * @example `dxn:type:com.example.type.person`
-     */
-    static fromTypename(typename: string): DXN;
-    /**
-     * @example `dxn:type:com.example.type.person:0.1.0`
-     */
-    static fromTypenameAndVersion(typename: string, version: string): DXN;
-    /**
-     * @example `dxn:echo:BA25QRC2FEWCSAMRP4RZL65LWJ7352CKE:01J00J9B45YHYSGZQTQMSKMGJ6`
-     */
-    static fromSpaceAndObjectId(spaceId: SpaceId, objectId: ObjectId): DXN;
-    /**
-     * @example `dxn:echo:@:01J00J9B45YHYSGZQTQMSKMGJ6`
-     */
-    static fromLocalObjectId(id: string): DXN;
-    static fromQueue(subspaceTag: QueueSubspaceTag, spaceId: SpaceId, queueId: ObjectId, objectId?: ObjectId): DXN;
-    constructor(kind: string, parts: string[]);
-    toString(): DXN.String;
-    toJSON(): string;
-    /**
-     * Used by Node.js to get textual representation of this object when it's printed with a `console.log` statement.
-     */
-    [inspectCustom](depth: number, options: InspectOptionsStylized, inspectFn: typeof inspect): string;
-    get [devtoolsFormatter](): DevtoolsFormatter;
-    get kind(): string;
-    get parts(): string[];
-    get typename(): string;
-    equals(other: DXN): boolean;
-    hasTypenameOf(typename: string): boolean;
-    isLocalObjectId(): boolean;
-    asTypeDXN(): DXN.TypeDXN | undefined;
-    asEchoDXN(): DXN.EchoDXN | undefined;
-    asQueueDXN(): DXN.QueueDXN | undefined;
-    /**
-     * Produces a new DXN with the given parts appended.
-     */
-    extend(parts: string[]): DXN;
-}
-/**
- * API namespace.
- */
-export declare namespace DXN {
-    /**
-     * DXN represented as a javascript string.
-     */
-    type String = string & {
-        __DXNString: never;
-    };
-    type TypeDXN = {
-        type: string;
-        version?: string;
-    };
-    type EchoDXN = {
-        spaceId?: SpaceId;
-        echoId: string;
-    };
-    type QueueDXN = {
-        subspaceTag: QueueSubspaceTag;
-        spaceId: SpaceId;
-        queueId: string;
-        objectId?: string;
-    };
-}
-//# sourceMappingURL=dxn.d.ts.map

package/dist/types/src/dxn.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"dxn.d.ts","sourceRoot":"","sources":["../../../src/dxn.ts"],"names":[],"mappings":"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"}

package/dist/types/src/object-id.d.ts

@@ -1,65 +0,0 @@
-import * as Schema from 'effect/Schema';
-declare const ObjectIdSchema: Schema.refine<string, typeof Schema.String>;
-export type ObjectId = typeof ObjectIdSchema.Type;
-export interface ObjectIdClass extends Schema.SchemaClass<ObjectId, string> {
-    /**
-     * @returns true if the string is a valid ObjectId.
-     */
-    isValid(id: string): id is ObjectId;
-    /**
-     * Creates an ObjectId from a string validating the format.
-     */
-    make(id: string): ObjectId;
-    /**
-     * Generates a random ObjectId.
-     */
-    random(): ObjectId;
-    /**
-     * WARNING: To be used only within tests.
-     *
-     * Disables randomness in ObjectId generation, causing the same sequence of IDs to be generated.
-     * Do not use in production code as this will cause data collisions.
-     * Place this at the top of the test file to ensure that the same sequence of IDs is generated.
-     *
-     * ```ts
-     * ObjectId.dangerouslyDisableRandomness();
-     *
-     * describe('suite', () => {
-     *   // ...
-     * });
-     * ```
-     *
-     * NOTE: The generated IDs depend on the order of ObjectId.random() calls, which might be affected by test order, scheduling, etc.
-     */
-    dangerouslyDisableRandomness(): void;
-}
-/**
- * Randomly generated unique identifier for an object.
- *
- * Follows ULID spec.
- */
-export declare const ObjectId: ObjectIdClass;
-/**
- * Simple Linear Congruential Generator (LCG) for pseudo-random number generation.
- * Returns numbers in the range [0, 1) (0 inclusive, 1 exclusive).
- */
-export declare class SimplePRNG {
-    #private;
-    /**
-     * Creates a new PRNG instance.
-     * @param seed - Initial seed value. If not provided, uses 0.
-     */
-    constructor(seed?: number);
-    /**
-     * Generates the next pseudo-random number in the range [0, 1).
-     * @returns A pseudo-random number between 0 (inclusive) and 1 (exclusive).
-     */
-    next(): number;
-    /**
-     * Resets the generator with a new seed.
-     * @param seed - New seed value.
-     */
-    reset(seed: number): void;
-}
-export {};
-//# sourceMappingURL=object-id.d.ts.map

package/dist/types/src/object-id.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"object-id.d.ts","sourceRoot":"","sources":["../../../src/object-id.ts"],"names":[],"mappings":"AAIA,OAAO,KAAK,MAAM,MAAM,eAAe,CAAC;AAMxC,QAAA,MAAM,cAAc,6CAGlB,CAAC;AAEH,MAAM,MAAM,QAAQ,GAAG,OAAO,cAAc,CAAC,IAAI,CAAC;AAElD,MAAM,WAAW,aAAc,SAAQ,MAAM,CAAC,WAAW,CAAC,QAAQ,EAAE,MAAM,CAAC;IACzE;;OAEG;IACH,OAAO,CAAC,EAAE,EAAE,MAAM,GAAG,EAAE,IAAI,QAAQ,CAAC;IAEpC;;OAEG;IACH,IAAI,CAAC,EAAE,EAAE,MAAM,GAAG,QAAQ,CAAC;IAE3B;;OAEG;IACH,MAAM,IAAI,QAAQ,CAAC;IAEnB;;;;;;;;;;;;;;;;OAgBG;IACH,4BAA4B,IAAI,IAAI,CAAC;CACtC;AAED;;;;GAIG;AACH,eAAO,MAAM,QAAQ,EAAE,aAqBtB,CAAC;AAYF;;;GAGG;AACH,qBAAa,UAAU;;IAQrB;;;OAGG;gBACS,IAAI,GAAE,MAAU;IAI5B;;;OAGG;IACH,IAAI,IAAI,MAAM;IAQd;;;OAGG;IACH,KAAK,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI;CAG1B"}