@bjornpagen/bumbledb 0.1.0

package/dist/schema.js

@@ -0,0 +1,235 @@
+/**
+ * `schema()` — assembles relations and statements into a theory value (the
+ * `Theory` analog; what `Db.create`/`Db.open` take). Construction-time
+ * validation is the macro-EXPANSION-boundary analog and nothing more:
+ * membership, implied-key duplicates, duplicate statements, and a
+ * belt-and-braces handle re-verification. Everything semantically deeper
+ * (containment targets resolving declared keys, fresh-on-u64, …) is
+ * DELIBERATELY left to the engine's `SchemaError` at `Db.create` — the
+ * same judge, the same two-boundary split as Rust.
+ */
+import * as errors from "@superbuilders/errors";
+import { assertDeclarationOrderKey } from "#fields.ts";
+import { renderStatement } from "#statements.ts";
+/**
+ * Validates the relation record and collects the implied keys: the
+ * fresh-implied `R(field) -> R` per minted field and the closed auto-key
+ * `R(id) -> R` per closed relation, each rendered canonically so an
+ * explicit duplicate is caught by string identity with the renderer as the
+ * single spelling authority.
+ */
+function collectImplied(name, relations) {
+    const implied = new Set();
+    for (const [recordKey, member] of Object.entries(relations)) {
+        assertDeclarationOrderKey(`schema ${name} relation`, recordKey);
+        if (member.name !== recordKey) {
+            throw errors.new(`schema ${name}: record key ${recordKey} holds relation ${member.name} — the key must equal the relation's declared name`);
+        }
+        if ("handles" in member.data) {
+            implied.add(`${member.name}(id) -> ${member.name}`);
+            continue;
+        }
+        for (const declared of member.data.fields) {
+            if (declared.field.minted) {
+                implied.add(`${member.name}(${declared.name}) -> ${member.name}`);
+            }
+        }
+    }
+    return implied;
+}
+/** The relation values a statement addresses, for membership checking. */
+function statementOwners(statement) {
+    const data = statement.data;
+    if (data.kind === "key") {
+        return [data.owner];
+    }
+    return [data.source.owner, data.target.owner];
+}
+/**
+ * Requires every relation a statement addresses to be the IDENTICAL value
+ * the schema record declares — same-name-different-value is a forgery, not
+ * a membership.
+ */
+function verifyMembership(name, relations, statement, rendered) {
+    for (const owner of statementOwners(statement)) {
+        const member = relations[owner.name];
+        if (member === undefined) {
+            throw errors.new(`schema ${name}: relation ${owner.name} is not declared in this schema — ${rendered}`);
+        }
+        if (member !== owner) {
+            throw errors.new(`schema ${name}: statement references a different relation value named ${owner.name} than the one this schema declares — ${rendered}`);
+        }
+    }
+}
+/** Finds a face's field description by name, across both relation kinds. */
+function faceField(face, fieldName) {
+    const data = face.owner.data;
+    if ("handles" in data) {
+        const column = data.columns.find(function byName(candidate) {
+            return candidate.name === fieldName;
+        });
+        return column?.field;
+    }
+    const declared = data.fields.find(function byName(candidate) {
+        return candidate.name === fieldName;
+    });
+    return declared?.field;
+}
+/** Flattens one binding's literal set into its literals. */
+function bindingLiterals(set) {
+    if (set.kind === "one") {
+        return [set.literal];
+    }
+    return set.literals;
+}
+/**
+ * Re-verifies one binding's handle literals against the field's roster —
+ * belt-and-braces over what `where()` already resolved and the type level
+ * already blocked, so a forged binding fails here rather than at the
+ * engine boundary with a colder message.
+ */
+function verifyBindingHandles(name, face, binding, rendered) {
+    const field = faceField(face, binding.field);
+    for (const literal of bindingLiterals(binding.set)) {
+        if (literal.kind !== "handle") {
+            continue;
+        }
+        if (field?.closed === undefined) {
+            throw errors.new(`schema ${name}: ${face.owner.name}.${binding.field} is not a closed-relation reference — the handle literal ${literal.handle} is legal only on a field whose newtype is a closed relation's handle newtype — ${rendered}`);
+        }
+        if (!field.closed.handles.includes(literal.handle)) {
+            throw errors.new(`schema ${name}: closed relation ${field.closed.name} has no handle ${literal.handle} — ${rendered}`);
+        }
+    }
+}
+/** Walks every face of a statement through the handle re-verification. */
+function verifyHandles(name, statement, rendered) {
+    const data = statement.data;
+    if (data.kind === "key") {
+        return;
+    }
+    for (const face of [data.source, data.target]) {
+        for (const binding of face.selection) {
+            verifyBindingHandles(name, face, binding, rendered);
+        }
+    }
+}
+/**
+ * Resolves the closed relation a `(relation, field)` pair references
+ * through the DECLARED containments — the identical walk the engine's
+ * canonical renderer performs (`schema/render.rs` `closed_target_of`): one
+ * hop, source projecting exactly `[field]`, target projecting exactly the
+ * closed relation's `[id]`, first declared match wins; a `mirrors`
+ * contributes both of its materialized orientations. `undefined` = the
+ * engine would render the field's selection literals as raw row ids.
+ */
+function closedTargetOf(statements, owner, field) {
+    for (const statement of statements) {
+        const data = statement.data;
+        if (data.kind !== "containment") {
+            continue;
+        }
+        const pairs = [[data.source, data.target]];
+        if (data.bidirectional) {
+            pairs.push([data.target, data.source]);
+        }
+        for (const [source, target] of pairs) {
+            if (source.owner.name === owner &&
+                source.projection.length === 1 &&
+                source.projection[0] === field &&
+                target.projection.length === 1 &&
+                target.projection[0] === "id" &&
+                "handles" in target.owner.data) {
+                return target.owner.name;
+            }
+        }
+    }
+    return undefined;
+}
+/**
+ * Admits a handle spelling only when the schema also declares the
+ * containment the ENGINE's canonical renderer resolves it through
+ * (`docs/architecture/10-data-model.md` § closed relations: a closed
+ * reference is the plain u64 column PLUS a declared containment). Without
+ * it the two renderers drift — `renderStatement` prints the handle name,
+ * the engine's violation `canonical` prints the raw row id — and the
+ * paste-back law (`violation.canonical === renderStatement(statement)`)
+ * breaks. Runs over the COMPLETE statement list, so declaration order
+ * never matters. The closed relation's own `id` field resolves directly
+ * (the walk's field-0 case).
+ */
+function verifyClosedReferences(name, statements) {
+    for (const statement of statements) {
+        const data = statement.data;
+        if (data.kind === "key") {
+            continue;
+        }
+        const rendered = renderStatement(statement);
+        for (const face of [data.source, data.target]) {
+            for (const binding of face.selection) {
+                verifyClosedReferenceBinding(name, statements, face, binding, rendered);
+            }
+        }
+    }
+}
+/** One binding's closed-reference resolution check (the {@link verifyClosedReferences} leaf). */
+function verifyClosedReferenceBinding(name, statements, face, binding, rendered) {
+    const spellsHandle = bindingLiterals(binding.set).some(function isHandle(literal) {
+        return literal.kind === "handle";
+    });
+    if (!spellsHandle) {
+        return;
+    }
+    const roster = faceField(face, binding.field)?.closed;
+    if (roster === undefined) {
+        return;
+    }
+    if ("handles" in face.owner.data && binding.field === "id") {
+        return;
+    }
+    const resolved = closedTargetOf(statements, face.owner.name, binding.field);
+    if (resolved !== roster.name) {
+        throw errors.new(`schema ${name}: ${face.owner.name}.${binding.field} spells a ${roster.name} handle, but no declared containment resolves the closed reference — a closed reference is the plain u64 column plus its declared containment; declare contained(on(${face.owner.name}, "${binding.field}"), on(${roster.name}, "id")) — ${rendered}`);
+    }
+}
+/**
+ * Assembles a theory:
+ * `schema("Ledger", { Kind, Account, Holder }, [ ...statements ])`.
+ *
+ * Rejected here, each with the offending statement rendered canonically:
+ * a record key differing from its relation's declared name; a statement
+ * whose relation is not (identically) a member of the record; an explicit
+ * duplicate of a fresh-implied or closedness-implied key (macro parity:
+ * "redundant here — and rejected as a duplicate"); a duplicate statement
+ * (two statements rendering to one canonical utterance ARE one judgment);
+ * a handle selection that its roster does not hold (belt-and-braces —
+ * the type level already blocks it); and a handle selection whose closed
+ * reference no declared containment resolves (the engine's canonical
+ * renderer would print the raw row id where `renderStatement` prints the
+ * handle — the paste-back law demands the two spellings agree).
+ *
+ * The fresh-implied and closed auto-keys are NOT added to the statement
+ * list: the engine materializes them itself, in its own pinned order
+ * (`SchemaDescriptor::materialized_statements`), and restating them would
+ * double them.
+ */
+function schema(name, relations, statements) {
+    const implied = collectImplied(name, relations);
+    const seen = new Set();
+    for (const statement of statements) {
+        const rendered = renderStatement(statement);
+        verifyMembership(name, relations, statement, rendered);
+        if (implied.has(rendered)) {
+            throw errors.new(`schema ${name}: ${rendered} is redundant here (the fresh mark or closedness already implies it) — and rejected as a duplicate`);
+        }
+        if (seen.has(rendered)) {
+            throw errors.new(`schema ${name}: duplicate statement — ${rendered}`);
+        }
+        seen.add(rendered);
+        verifyHandles(name, statement, rendered);
+    }
+    verifyClosedReferences(name, statements);
+    return Object.freeze({ name, relations, statements: Object.freeze([...statements]) });
+}
+export { schema };
+//# sourceMappingURL=schema.js.map

package/dist/schema.js.map

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

package/dist/spec.d.ts

@@ -0,0 +1,218 @@
+/**
+ * The lowered wire shapes — a 1:1 TypeScript mirror of bumbledb's
+ * `SchemaSpec` bindings contract (PRD-01;
+ * `bumbledb/crates/bumbledb/src/schema/spec.rs`): a schema as named plain
+ * data, relations and dependency statements each in declaration order (the
+ * declaration-order law that mints every id). The SDK's `lower()` emits
+ * these values; the napi bridge (PRD-04) marshals them into the Rust
+ * `SchemaSpec` verbatim, and the engine's own judge (`SchemaSpec::descriptor`
+ * name resolution + `SchemaDescriptor::validate` at `Db.create`/`Db.open`)
+ * stays the single semantic authority — the SDK lowers, it never re-judges.
+ *
+ * Every u64 crosses as `bigint`, never `number` (PRD-04's marshaling law: no
+ * 53-bit hazards, no branch). Object keys are always written in one fixed
+ * literal order per shape, so serialization of a lowered schema is
+ * deterministic (byte-stable) by construction.
+ */
+/**
+ * A structural value type — the one type vocabulary of the `schema!` field
+ * grammar (`ValueType` in Rust): `bool`, `u64`, `i64`, `str` (`string`
+ * here), `bytes<N>` (`fixedBytes`), and the interval family (`width:
+ * undefined` is the general 16-byte encoding with rays representable;
+ * `width: w` is the fixed-width `interval<E, w>` whose encoding stores only
+ * the start).
+ */
+type ValueTypeSpec = {
+    readonly kind: "bool";
+} | {
+    readonly kind: "u64";
+} | {
+    readonly kind: "i64";
+} | {
+    readonly kind: "string";
+} | {
+    readonly kind: "fixedBytes";
+    readonly len: number;
+} | {
+    readonly kind: "interval";
+    readonly element: "u64" | "i64";
+    readonly width: bigint | undefined;
+};
+/**
+ * One plain engine value as carried by a lowered literal — the mirror of
+ * `bumbledb::Value` restricted to the schema-literal vocabulary (Allen masks
+ * are query-side values, never schema literals). Intervals are half-open
+ * `[start, end)`.
+ */
+type ValueSpec = {
+    readonly kind: "bool";
+    readonly value: boolean;
+} | {
+    readonly kind: "u64";
+    readonly value: bigint;
+} | {
+    readonly kind: "i64";
+    readonly value: bigint;
+} | {
+    readonly kind: "string";
+    readonly value: string;
+} | {
+    readonly kind: "fixedBytes";
+    readonly value: Uint8Array;
+} | {
+    readonly kind: "intervalU64";
+    readonly start: bigint;
+    readonly end: bigint;
+} | {
+    readonly kind: "intervalI64";
+    readonly start: bigint;
+    readonly end: bigint;
+};
+/**
+ * One literal as spelled: a plain value, or a closed relation's handle by
+ * name (the `| status == Frozen` spelling) — resolved by the engine through
+ * the selected field's newtype to the handle's declaration-order row id,
+ * exactly as the macro resolves it at expansion.
+ */
+type LiteralSpec = {
+    readonly kind: "value";
+    readonly value: ValueSpec;
+} | {
+    readonly kind: "handle";
+    readonly handle: string;
+};
+/**
+ * One σ binding's right side: a single literal or a literal set (read
+ * disjunctively). The SDK's selection constructors make the degenerate sets
+ * unwritable (`oneOf` demands two leading literals), so a lowered `many`
+ * always carries ≥ 2 literals.
+ */
+type LiteralSetSpec = {
+    readonly kind: "one";
+    readonly literal: LiteralSpec;
+} | {
+    readonly kind: "many";
+    readonly literals: readonly LiteralSpec[];
+};
+/**
+ * One side of a containment or window: `R(fields… | field == literal…)`,
+ * all names. `projection` is π in the statement's written order (positional
+ * pairing with the other side); `selection` is σ as (field, literal-or-set)
+ * pairs, read conjunctively.
+ */
+interface SideSpec {
+    readonly relation: string;
+    readonly projection: readonly string[];
+    readonly selection: ReadonlyArray<readonly [string, LiteralSetSpec]>;
+}
+/**
+ * A cardinality window's bounds — the canonical-utterance law's surviving
+ * spellings only, since the SDK's `Count` constructors make every banned
+ * spelling unwritable or a construction error: `exact` is `{n}` (`{0}` the
+ * exclusion), `range` is `{lo..hi}` with lo < hi, `floor` is `{lo..*}` with
+ * lo ≥ 2.
+ */
+type WindowSpec = {
+    readonly kind: "exact";
+    readonly n: bigint;
+} | {
+    readonly kind: "range";
+    readonly lo: bigint;
+    readonly hi: bigint;
+} | {
+    readonly kind: "floor";
+    readonly lo: bigint;
+};
+/**
+ * One field: name, structural type, host newtype name (carried for handle
+ * resolution only — dropped by the engine at descriptor lowering), and the
+ * `fresh` mint mark.
+ */
+interface FieldSpec {
+    readonly name: string;
+    readonly valueType: ValueTypeSpec;
+    readonly newtype: string | undefined;
+    readonly fresh: boolean;
+}
+/**
+ * One ground axiom of a closed relation: the handle plus one literal per
+ * declared intrinsic column, in field-declaration order (row id = index).
+ */
+interface RowSpec {
+    readonly handle: string;
+    readonly values: readonly LiteralSpec[];
+}
+/**
+ * One relation. `extension: rows` declares it closed (the option is the
+ * kind); a closed relation's `fields` are its declared intrinsic columns
+ * only — the synthetic (`id`, u64) handle field is materialized by the
+ * engine's schema validation. `newtype` is the handle newtype of a closed
+ * relation (the SDK uses the closed relation's own name), undefined on an
+ * ordinary one.
+ */
+interface RelationSpec {
+    readonly name: string;
+    readonly newtype: string | undefined;
+    readonly fields: readonly FieldSpec[];
+    readonly extension: readonly RowSpec[] | undefined;
+}
+/**
+ * One dependency statement, tagged by form. `==` is not a variant: a
+ * bidirectional containment is `containment` with `bidirectional: true`,
+ * lowered by the engine to the two adjacent containments (`source <=
+ * target` first). `cardinality` is B-family, target-left: the target is the
+ * per-group parent, the source is counted.
+ */
+type StatementSpec = {
+    readonly kind: "fd";
+    readonly relation: string;
+    readonly projection: readonly string[];
+} | {
+    readonly kind: "containment";
+    readonly source: SideSpec;
+    readonly target: SideSpec;
+    readonly bidirectional: boolean;
+} | {
+    readonly kind: "cardinality";
+    readonly target: SideSpec;
+    readonly window: WindowSpec;
+    readonly source: SideSpec;
+};
+/**
+ * The whole theory as named plain data — what `lower()` produces and what
+ * the bridge's `dbCreate`/`dbOpen` take. Both lists are in declaration
+ * order. Only DECLARED statements appear: the engine materializes the
+ * fresh-implied and closed auto-keys itself
+ * (`SchemaDescriptor::materialized_statements` — fresh keys first, closed
+ * auto-keys second, declared statements last), so re-stating them here
+ * would double them and change the fingerprint.
+ */
+interface SchemaSpec {
+    readonly relations: readonly RelationSpec[];
+    readonly statements: readonly StatementSpec[];
+}
+/**
+ * Renders one lowered literal in the exact macro spelling the engine's own
+ * renderer uses (`schema/render.rs` `literal`): handles bare by name,
+ * integers as digits, `true`/`false`, intervals as `start..end`, strings
+ * char-escaped through the `char::escape_debug` mirror, bytes as `b"…"`
+ * byte-escaped through the `u8::escape_ascii` mirror — byte-for-byte the
+ * engine's violation canonicals, so TS-side construction errors and
+ * engine-side violations read identically and `renderStatement` equals the
+ * violation's `canonical`.
+ */
+declare function renderLiteral(literal: LiteralSpec): string;
+/**
+ * Renders one σ binding's right side: a bare literal, or a disjunctive
+ * literal set in braces (`{A, B}`).
+ */
+declare function renderLiteralSet(set: LiteralSetSpec): string;
+/**
+ * Renders window bounds in their one canonical spelling: `{n}` exact
+ * (`{0}` the exclusion), `{lo..hi}`, `{lo..*}` — the spelling set the
+ * engine's renderer emits for sealed statements.
+ */
+declare function renderWindow(window: WindowSpec): string;
+export type { FieldSpec, LiteralSetSpec, LiteralSpec, RelationSpec, RowSpec, SchemaSpec, SideSpec, StatementSpec, ValueSpec, ValueTypeSpec, WindowSpec };
+export { renderLiteral, renderLiteralSet, renderWindow };
+//# sourceMappingURL=spec.d.ts.map

package/dist/spec.d.ts.map

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

package/dist/spec.js

@@ -0,0 +1,154 @@
+/**
+ * The lowered wire shapes — a 1:1 TypeScript mirror of bumbledb's
+ * `SchemaSpec` bindings contract (PRD-01;
+ * `bumbledb/crates/bumbledb/src/schema/spec.rs`): a schema as named plain
+ * data, relations and dependency statements each in declaration order (the
+ * declaration-order law that mints every id). The SDK's `lower()` emits
+ * these values; the napi bridge (PRD-04) marshals them into the Rust
+ * `SchemaSpec` verbatim, and the engine's own judge (`SchemaSpec::descriptor`
+ * name resolution + `SchemaDescriptor::validate` at `Db.create`/`Db.open`)
+ * stays the single semantic authority — the SDK lowers, it never re-judges.
+ *
+ * Every u64 crosses as `bigint`, never `number` (PRD-04's marshaling law: no
+ * 53-bit hazards, no branch). Object keys are always written in one fixed
+ * literal order per shape, so serialization of a lowered schema is
+ * deterministic (byte-stable) by construction.
+ */
+/**
+ * The characters Rust's `char::escape_debug` (the engine renderer's string
+ * formatter, `schema/render.rs` `literal`) escapes as `\u{…}`: everything
+ * non-printable per rustc's generated tables — the C categories (Cc, Cf,
+ * Cs, Co, Cn) and the Z separators (Zs, Zl, Zp) except U+0020 itself
+ * (`library/core/src/unicode/printable.py`).
+ */
+const NON_PRINTABLE = /[\p{C}\p{Z}]/u;
+/** Grapheme-extending characters, which `char::escape_debug` always escapes even when printable. */
+const GRAPHEME_EXTEND = /\p{Grapheme_Extend}/u;
+/**
+ * One char exactly as Rust's `char::escape_debug` spells it (the engine
+ * renders strings char by char through it): `\0`, `\t`, `\r`, `\n`,
+ * backslash-escaped `\\`/`\'`/`\"`, `\u{hex}` (lowercase, unpadded) for
+ * grapheme-extending and non-printable chars, the char itself otherwise.
+ */
+function escapeDebugChar(ch) {
+    if (ch === "\0") {
+        return "\\0";
+    }
+    if (ch === "\t") {
+        return "\\t";
+    }
+    if (ch === "\r") {
+        return "\\r";
+    }
+    if (ch === "\n") {
+        return "\\n";
+    }
+    if (ch === "\\" || ch === "'" || ch === '"') {
+        return `\\${ch}`;
+    }
+    if (GRAPHEME_EXTEND.test(ch) || (ch !== " " && NON_PRINTABLE.test(ch))) {
+        const codePoint = ch.codePointAt(0);
+        if (codePoint === undefined) {
+            return ch;
+        }
+        return `\\u{${codePoint.toString(16)}}`;
+    }
+    return ch;
+}
+/**
+ * One byte exactly as Rust's `u8::escape_ascii` spells it (the engine
+ * renders `bytes<N>` literals byte by byte through it): `\t`, `\r`, `\n`,
+ * `\\`, `\'`, `\"` as two-char escapes, printable ASCII (0x20–0x7e)
+ * verbatim, everything else `\xNN` lowercase.
+ */
+function escapeAsciiByte(byte) {
+    if (byte === 0x09) {
+        return "\\t";
+    }
+    if (byte === 0x0d) {
+        return "\\r";
+    }
+    if (byte === 0x0a) {
+        return "\\n";
+    }
+    if (byte === 0x5c) {
+        return "\\\\";
+    }
+    if (byte === 0x27) {
+        return "\\'";
+    }
+    if (byte === 0x22) {
+        return '\\"';
+    }
+    if (byte >= 0x20 && byte <= 0x7e) {
+        return String.fromCharCode(byte);
+    }
+    return `\\x${byte.toString(16).padStart(2, "0")}`;
+}
+/**
+ * Renders one lowered literal in the exact macro spelling the engine's own
+ * renderer uses (`schema/render.rs` `literal`): handles bare by name,
+ * integers as digits, `true`/`false`, intervals as `start..end`, strings
+ * char-escaped through the `char::escape_debug` mirror, bytes as `b"…"`
+ * byte-escaped through the `u8::escape_ascii` mirror — byte-for-byte the
+ * engine's violation canonicals, so TS-side construction errors and
+ * engine-side violations read identically and `renderStatement` equals the
+ * violation's `canonical`.
+ */
+function renderLiteral(literal) {
+    if (literal.kind === "handle") {
+        return literal.handle;
+    }
+    const value = literal.value;
+    switch (value.kind) {
+        case "bool":
+            return value.value ? "true" : "false";
+        case "u64":
+        case "i64":
+            return value.value.toString();
+        case "string": {
+            let out = '"';
+            for (const ch of value.value) {
+                out += escapeDebugChar(ch);
+            }
+            return `${out}"`;
+        }
+        case "fixedBytes": {
+            let out = 'b"';
+            for (const byte of value.value) {
+                out += escapeAsciiByte(byte);
+            }
+            return `${out}"`;
+        }
+        case "intervalU64":
+        case "intervalI64":
+            return `${value.start}..${value.end}`;
+    }
+}
+/**
+ * Renders one σ binding's right side: a bare literal, or a disjunctive
+ * literal set in braces (`{A, B}`).
+ */
+function renderLiteralSet(set) {
+    if (set.kind === "one") {
+        return renderLiteral(set.literal);
+    }
+    return `{${set.literals.map(renderLiteral).join(", ")}}`;
+}
+/**
+ * Renders window bounds in their one canonical spelling: `{n}` exact
+ * (`{0}` the exclusion), `{lo..hi}`, `{lo..*}` — the spelling set the
+ * engine's renderer emits for sealed statements.
+ */
+function renderWindow(window) {
+    switch (window.kind) {
+        case "exact":
+            return `{${window.n}}`;
+        case "range":
+            return `{${window.lo}..${window.hi}}`;
+        case "floor":
+            return `{${window.lo}..*}`;
+    }
+}
+export { renderLiteral, renderLiteralSet, renderWindow };
+//# sourceMappingURL=spec.js.map

package/dist/spec.js.map

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