ushman-equiv 0.4.0

package/dist/ast-guards.d.ts

@@ -0,0 +1,24 @@
+import { type ArrayPattern, type AssignmentPattern, type CallExpression, type ClassDeclaration, type ExportAllDeclaration, type ExportDefaultDeclaration, type ExportNamedDeclaration, type ExportSpecifier, type FunctionDeclaration, type Identifier, type ImportDeclaration, type ImportDefaultSpecifier, type ImportNamespaceSpecifier, type ImportSpecifier, type Node, type ObjectPattern, type ObjectProperty, type RestElement, type StringLiteral, type VariableDeclaration, type VariableDeclarator } from '@babel/types';
+export declare const isRecord: (value: unknown) => value is Record<string, unknown>;
+export declare const asNode: (value: unknown) => Node | null;
+export declare const isArrayPatternNode: (value: unknown) => value is ArrayPattern;
+export declare const isAssignmentPatternNode: (value: unknown) => value is AssignmentPattern;
+export declare const isCallExpressionNode: (value: unknown) => value is CallExpression;
+export declare const isClassDeclarationNode: (value: unknown) => value is ClassDeclaration;
+export declare const isExportAllDeclarationNode: (value: unknown) => value is ExportAllDeclaration;
+export declare const isExportDefaultDeclarationNode: (value: unknown) => value is ExportDefaultDeclaration;
+export declare const isExportNamedDeclarationNode: (value: unknown) => value is ExportNamedDeclaration;
+export declare const isExportSpecifierNode: (value: unknown) => value is ExportSpecifier;
+export declare const isFunctionDeclarationNode: (value: unknown) => value is FunctionDeclaration;
+export declare const isIdentifierNode: (value: unknown) => value is Identifier;
+export declare const isImportDeclarationNode: (value: unknown) => value is ImportDeclaration;
+export declare const isImportDefaultSpecifierNode: (value: unknown) => value is ImportDefaultSpecifier;
+export declare const isImportNamespaceSpecifierNode: (value: unknown) => value is ImportNamespaceSpecifier;
+export declare const isImportSpecifierNode: (value: unknown) => value is ImportSpecifier;
+export declare const isObjectPatternNode: (value: unknown) => value is ObjectPattern;
+export declare const isObjectPropertyNode: (value: unknown) => value is ObjectProperty;
+export declare const isRestElementNode: (value: unknown) => value is RestElement;
+export declare const isStringLiteralNode: (value: unknown) => value is StringLiteral;
+export declare const isVariableDeclarationNode: (value: unknown) => value is VariableDeclaration;
+export declare const isVariableDeclaratorNode: (value: unknown) => value is VariableDeclarator;
+//# sourceMappingURL=ast-guards.d.ts.map

package/dist/ast-guards.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-guards.d.ts","sourceRoot":"","sources":["../src/ast-guards.ts"],"names":[],"mappings":"AAAA,OAAO,EAqBH,KAAK,YAAY,EACjB,KAAK,iBAAiB,EACtB,KAAK,cAAc,EACnB,KAAK,gBAAgB,EACrB,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,KAAK,sBAAsB,EAC3B,KAAK,eAAe,EACpB,KAAK,mBAAmB,EACxB,KAAK,UAAU,EACf,KAAK,iBAAiB,EACtB,KAAK,sBAAsB,EAC3B,KAAK,wBAAwB,EAC7B,KAAK,eAAe,EACpB,KAAK,IAAI,EACT,KAAK,aAAa,EAClB,KAAK,cAAc,EACnB,KAAK,WAAW,EAChB,KAAK,aAAa,EAClB,KAAK,mBAAmB,EACxB,KAAK,kBAAkB,EAC1B,MAAM,cAAc,CAAC;AAEtB,eAAO,MAAM,QAAQ,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,MAAM,CAAC,MAAM,EAAE,OAAO,CACD,CAAC;AAEzE,eAAO,MAAM,MAAM,GAAI,OAAO,OAAO,KAAG,IAAI,GAAG,IAA6D,CAAC;AAE7G,eAAO,MAAM,kBAAkB,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,YAG5D,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,iBAGjE,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,cAG9D,CAAC;AAEF,eAAO,MAAM,sBAAsB,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,gBAGhE,CAAC;AAEF,eAAO,MAAM,0BAA0B,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,oBAGpE,CAAC;AAEF,eAAO,MAAM,8BAA8B,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,wBAGxE,CAAC;AAEF,eAAO,MAAM,4BAA4B,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,sBAGtE,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,eAG/D,CAAC;AAEF,eAAO,MAAM,yBAAyB,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,mBAGnE,CAAC;AAEF,eAAO,MAAM,gBAAgB,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,UAG1D,CAAC;AAEF,eAAO,MAAM,uBAAuB,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,iBAGjE,CAAC;AAEF,eAAO,MAAM,4BAA4B,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,sBAGtE,CAAC;AAEF,eAAO,MAAM,8BAA8B,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,wBAGxE,CAAC;AAEF,eAAO,MAAM,qBAAqB,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,eAG/D,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,aAG7D,CAAC;AAEF,eAAO,MAAM,oBAAoB,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,cAG9D,CAAC;AAEF,eAAO,MAAM,iBAAiB,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,WAG3D,CAAC;AAEF,eAAO,MAAM,mBAAmB,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,aAG7D,CAAC;AAEF,eAAO,MAAM,yBAAyB,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,mBAGnE,CAAC;AAEF,eAAO,MAAM,wBAAwB,GAAI,OAAO,OAAO,KAAG,KAAK,IAAI,kBAGlE,CAAC"}

package/dist/ast-guards.js

@@ -0,0 +1,83 @@
+import { isArrayPattern, isAssignmentPattern, isCallExpression, isClassDeclaration, isExportAllDeclaration, isExportDefaultDeclaration, isExportNamedDeclaration, isExportSpecifier, isFunctionDeclaration, isIdentifier, isImportDeclaration, isImportDefaultSpecifier, isImportNamespaceSpecifier, isImportSpecifier, isObjectPattern, isObjectProperty, isRestElement, isStringLiteral, isVariableDeclaration, isVariableDeclarator, } from '@babel/types';
+export const isRecord = (value) => value !== null && typeof value === 'object' && !Array.isArray(value);
+export const asNode = (value) => (isRecord(value) ? value : null);
+export const isArrayPatternNode = (value) => {
+    const node = asNode(value);
+    return node !== null && isArrayPattern(node);
+};
+export const isAssignmentPatternNode = (value) => {
+    const node = asNode(value);
+    return node !== null && isAssignmentPattern(node);
+};
+export const isCallExpressionNode = (value) => {
+    const node = asNode(value);
+    return node !== null && isCallExpression(node);
+};
+export const isClassDeclarationNode = (value) => {
+    const node = asNode(value);
+    return node !== null && isClassDeclaration(node);
+};
+export const isExportAllDeclarationNode = (value) => {
+    const node = asNode(value);
+    return node !== null && isExportAllDeclaration(node);
+};
+export const isExportDefaultDeclarationNode = (value) => {
+    const node = asNode(value);
+    return node !== null && isExportDefaultDeclaration(node);
+};
+export const isExportNamedDeclarationNode = (value) => {
+    const node = asNode(value);
+    return node !== null && isExportNamedDeclaration(node);
+};
+export const isExportSpecifierNode = (value) => {
+    const node = asNode(value);
+    return node !== null && isExportSpecifier(node);
+};
+export const isFunctionDeclarationNode = (value) => {
+    const node = asNode(value);
+    return node !== null && isFunctionDeclaration(node);
+};
+export const isIdentifierNode = (value) => {
+    const node = asNode(value);
+    return node !== null && isIdentifier(node);
+};
+export const isImportDeclarationNode = (value) => {
+    const node = asNode(value);
+    return node !== null && isImportDeclaration(node);
+};
+export const isImportDefaultSpecifierNode = (value) => {
+    const node = asNode(value);
+    return node !== null && isImportDefaultSpecifier(node);
+};
+export const isImportNamespaceSpecifierNode = (value) => {
+    const node = asNode(value);
+    return node !== null && isImportNamespaceSpecifier(node);
+};
+export const isImportSpecifierNode = (value) => {
+    const node = asNode(value);
+    return node !== null && isImportSpecifier(node);
+};
+export const isObjectPatternNode = (value) => {
+    const node = asNode(value);
+    return node !== null && isObjectPattern(node);
+};
+export const isObjectPropertyNode = (value) => {
+    const node = asNode(value);
+    return node !== null && isObjectProperty(node);
+};
+export const isRestElementNode = (value) => {
+    const node = asNode(value);
+    return node !== null && isRestElement(node);
+};
+export const isStringLiteralNode = (value) => {
+    const node = asNode(value);
+    return node !== null && isStringLiteral(node);
+};
+export const isVariableDeclarationNode = (value) => {
+    const node = asNode(value);
+    return node !== null && isVariableDeclaration(node);
+};
+export const isVariableDeclaratorNode = (value) => {
+    const node = asNode(value);
+    return node !== null && isVariableDeclarator(node);
+};

package/dist/candidate-boot.d.ts

@@ -0,0 +1,30 @@
+import type { ChildProcess } from 'node:child_process';
+import type { EquivMode } from './types.ts';
+export type CandidateBootSmoke = {
+    readonly mode: EquivMode;
+};
+export type CandidateBootSmokeResult = (CandidateBootSmoke & {
+    readonly diagnostics?: never;
+    readonly ok: true;
+}) | (CandidateBootSmoke & {
+    readonly diagnostics: string;
+    readonly ok: false;
+});
+type CandidateBootRuntime = {
+    readonly resolveOpenPort: () => Promise<number>;
+    readonly spawnModeProcess: (options: {
+        readonly mode: EquivMode;
+        readonly port: number;
+        readonly workspaceRoot: string;
+    }) => ChildProcess;
+};
+export declare const smokeCandidateBootWithDependencies: ({ mode, workspaceRoot, }: {
+    readonly mode?: EquivMode;
+    readonly workspaceRoot: string;
+}, dependencies?: Partial<CandidateBootRuntime>) => Promise<CandidateBootSmokeResult>;
+export declare const smokeCandidateBoot: ({ mode, workspaceRoot, }: {
+    readonly mode?: EquivMode;
+    readonly workspaceRoot: string;
+}) => Promise<CandidateBootSmokeResult>;
+export {};
+//# sourceMappingURL=candidate-boot.d.ts.map

package/dist/candidate-boot.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"candidate-boot.d.ts","sourceRoot":"","sources":["../src/candidate-boot.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAIvD,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AAY5C,MAAM,MAAM,kBAAkB,GAAG;IAC7B,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;CAC5B,CAAC;AAEF,MAAM,MAAM,wBAAwB,GAC9B,CAAC,kBAAkB,GAAG;IAAE,QAAQ,CAAC,WAAW,CAAC,EAAE,KAAK,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,IAAI,CAAA;CAAE,CAAC,GAC1E,CAAC,kBAAkB,GAAG;IAAE,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAAC,QAAQ,CAAC,EAAE,EAAE,KAAK,CAAA;CAAE,CAAC,CAAC;AAElF,KAAK,oBAAoB,GAAG;IACxB,QAAQ,CAAC,eAAe,EAAE,MAAM,OAAO,CAAC,MAAM,CAAC,CAAC;IAChD,QAAQ,CAAC,gBAAgB,EAAE,CAAC,OAAO,EAAE;QACjC,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;QACzB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;KAClC,KAAK,YAAY,CAAC;CACtB,CAAC;AAqRF,eAAO,MAAM,kCAAkC,GAC3C,0BAGG;IACC,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC;IAC1B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAClC,EACD,eAAc,OAAO,CAAC,oBAAoB,CAAM,KACjD,OAAO,CAAC,wBAAwB,CAiDlC,CAAC;AAEF,eAAO,MAAM,kBAAkB,GAAU,0BAGtC;IACC,QAAQ,CAAC,IAAI,CAAC,EAAE,SAAS,CAAC;IAC1B,QAAQ,CAAC,aAAa,EAAE,MAAM,CAAC;CAClC,KAAG,OAAO,CAAC,wBAAwB,CAO/B,CAAC"}

package/dist/candidate-boot.js

@@ -0,0 +1,262 @@
+import { spawn } from 'node:child_process';
+import { createServer } from 'node:net';
+import { captureChildText, readPositiveIntegerEnv } from "./shared.js";
+import { DEFAULT_EQUIV_MODE } from "./workspace.js";
+const BUN_EXECUTABLE = process.env.BUN_EXECUTABLE ?? 'bun';
+const BOOT_TIMEOUT_MS = readPositiveIntegerEnv('USHMAN_EQUIV_BOOT_TIMEOUT_MS', 15_000);
+const BUILD_TIMEOUT_MS = readPositiveIntegerEnv('USHMAN_EQUIV_BUILD_TIMEOUT_MS', 120_000);
+const BOOT_PORT_RETRY_LIMIT = readPositiveIntegerEnv('USHMAN_EQUIV_BOOT_PORT_RETRY_LIMIT', 3);
+const MAX_LOG_BYTES = readPositiveIntegerEnv('USHMAN_EQUIV_MAX_LOG_BYTES', 32 * 1024);
+const READY_POLL_INTERVAL_MS = readPositiveIntegerEnv('USHMAN_EQUIV_READY_POLL_INTERVAL_MS', 150);
+const ADDRESS_IN_USE_CODE = 'EADDRINUSE';
+const sleep = (delayMs) => new Promise((resolve) => {
+    setTimeout(resolve, delayMs);
+});
+const waitForExit = async (child, timeoutMs) => {
+    if (child.exitCode !== null) {
+        return true;
+    }
+    return await new Promise((resolve) => {
+        const onExit = () => {
+            clearTimeout(timeoutId);
+            resolve(true);
+        };
+        const timeoutId = setTimeout(() => {
+            child.removeListener('exit', onExit);
+            resolve(false);
+        }, timeoutMs);
+        child.once('exit', onExit);
+    });
+};
+const resolveOpenPort = async () => new Promise((resolve, reject) => {
+    const server = createServer();
+    server.once('error', reject);
+    server.listen(0, '127.0.0.1', () => {
+        const address = server.address();
+        if (!address || typeof address === 'string') {
+            reject(new Error('Failed to resolve an open port.'));
+            return;
+        }
+        server.close((error) => {
+            if (error) {
+                reject(error);
+                return;
+            }
+            resolve(address.port);
+        });
+    });
+});
+const closeChild = async (child) => {
+    if (child.exitCode !== null) {
+        return;
+    }
+    child.kill('SIGTERM');
+    if (await waitForExit(child, 2_000)) {
+        return;
+    }
+    child.kill('SIGKILL');
+    await waitForExit(child, 2_000);
+};
+const formatDiagnostics = ({ context, stderr, stdout, }) => [context, stderr ? `stderr:\n${stderr}` : null, stdout ? `stdout:\n${stdout}` : null]
+    .filter((line) => Boolean(line))
+    .join('\n\n');
+const formatRetryExhaustedDiagnostics = ({ attempts, diagnostics, }) => [
+    `Candidate boot hit ${ADDRESS_IN_USE_CODE} ${attempts} time${attempts === 1 ? '' : 's'} while retrying strict port allocation.`,
+    diagnostics,
+].join('\n\n');
+const runBuild = async (workspaceRoot) => {
+    const child = spawn(BUN_EXECUTABLE, ['run', 'build'], {
+        cwd: workspaceRoot,
+        stdio: ['ignore', 'pipe', 'pipe'],
+    });
+    const readStdout = captureChildText({
+        maxBytes: MAX_LOG_BYTES,
+        stream: child.stdout,
+    });
+    const readStderr = captureChildText({
+        maxBytes: MAX_LOG_BYTES,
+        stream: child.stderr,
+    });
+    const buildState = await Promise.race([
+        new Promise((resolve) => {
+            child.once('error', (error) => resolve({
+                error,
+                finished: false,
+            }));
+        }),
+        waitForExit(child, BUILD_TIMEOUT_MS).then((finished) => ({
+            error: null,
+            finished,
+        })),
+    ]);
+    if (buildState.error) {
+        return formatDiagnostics({
+            context: `bun run build failed to start: ${buildState.error.message}`,
+            stderr: readStderr(),
+            stdout: readStdout(),
+        });
+    }
+    if (!buildState.finished) {
+        await closeChild(child);
+        return formatDiagnostics({
+            context: `bun run build timed out after ${BUILD_TIMEOUT_MS}ms.`,
+            stderr: readStderr(),
+            stdout: readStdout(),
+        });
+    }
+    if (child.exitCode !== 0) {
+        return formatDiagnostics({
+            context: `bun run build exited with code ${child.exitCode ?? 'unknown'}.`,
+            stderr: readStderr(),
+            stdout: readStdout(),
+        });
+    }
+    return null;
+};
+const spawnModeProcess = ({ mode, port, workspaceRoot, }) => spawn(BUN_EXECUTABLE, [
+    'run',
+    mode === 'preview' ? 'preview' : 'dev',
+    '--',
+    '--host',
+    '127.0.0.1',
+    '--port',
+    String(port),
+    '--strictPort',
+], {
+    cwd: workspaceRoot,
+    env: {
+        ...process.env,
+        NODE_ENV: mode === 'preview' ? 'production' : 'development',
+    },
+    stdio: ['ignore', 'pipe', 'pipe'],
+});
+const shouldRetryPortContention = (diagnostics) => diagnostics.includes(ADDRESS_IN_USE_CODE);
+const waitForServerReady = async ({ child, onError, processLabel, stderr, stdout, url, }) => {
+    const startedAt = Date.now();
+    while (Date.now() - startedAt < BOOT_TIMEOUT_MS) {
+        const childError = onError();
+        if (childError) {
+            throw new Error(formatDiagnostics({
+                context: `${processLabel} failed to start: ${childError.message}`,
+                stderr: stderr(),
+                stdout: stdout(),
+            }));
+        }
+        if (child.exitCode !== null) {
+            throw new Error(formatDiagnostics({
+                context: `${processLabel} exited with code ${child.exitCode}.`,
+                stderr: stderr(),
+                stdout: stdout(),
+            }));
+        }
+        try {
+            const response = await fetch(url);
+            if (response.ok || response.status === 404) {
+                return;
+            }
+        }
+        catch { }
+        await sleep(READY_POLL_INTERVAL_MS);
+    }
+    throw new Error(formatDiagnostics({
+        context: `Timed out waiting for ${url}.`,
+        stderr: stderr(),
+        stdout: stdout(),
+    }));
+};
+const attemptCandidateBoot = async ({ mode = DEFAULT_EQUIV_MODE, runtime, workspaceRoot, }) => {
+    const port = await runtime.resolveOpenPort();
+    const child = runtime.spawnModeProcess({
+        mode,
+        port,
+        workspaceRoot,
+    });
+    const readStdout = captureChildText({
+        maxBytes: MAX_LOG_BYTES,
+        stream: child.stdout,
+    });
+    const readStderr = captureChildText({
+        maxBytes: MAX_LOG_BYTES,
+        stream: child.stderr,
+    });
+    let childError = null;
+    child.once('error', (error) => {
+        childError = error;
+    });
+    const url = `http://127.0.0.1:${port}/`;
+    const processLabel = mode === 'preview' ? 'Preview process' : 'Dev process';
+    try {
+        await waitForServerReady({
+            child,
+            onError: () => childError,
+            processLabel,
+            stderr: readStderr,
+            stdout: readStdout,
+            url,
+        });
+        return {
+            ok: true,
+        };
+    }
+    catch (error) {
+        return {
+            diagnostics: error instanceof Error ? error.message : String(error),
+            ok: false,
+        };
+    }
+    finally {
+        await closeChild(child);
+    }
+};
+// Internal test seam for simulating boot races without widening the public package API.
+export const smokeCandidateBootWithDependencies = async ({ mode = DEFAULT_EQUIV_MODE, workspaceRoot, }, dependencies = {}) => {
+    if (mode === 'preview') {
+        const buildFailure = await runBuild(workspaceRoot);
+        if (buildFailure) {
+            return {
+                diagnostics: buildFailure,
+                mode,
+                ok: false,
+            };
+        }
+    }
+    const runtime = {
+        resolveOpenPort: dependencies.resolveOpenPort ?? resolveOpenPort,
+        spawnModeProcess: dependencies.spawnModeProcess ?? spawnModeProcess,
+    };
+    for (let attempt = 1; attempt <= BOOT_PORT_RETRY_LIMIT; attempt += 1) {
+        const attemptResult = await attemptCandidateBoot({
+            mode,
+            runtime,
+            workspaceRoot,
+        });
+        if (attemptResult.ok) {
+            return {
+                mode,
+                ok: true,
+            };
+        }
+        if (!shouldRetryPortContention(attemptResult.diagnostics)) {
+            return {
+                diagnostics: attemptResult.diagnostics,
+                mode,
+                ok: false,
+            };
+        }
+        if (attempt === BOOT_PORT_RETRY_LIMIT) {
+            return {
+                diagnostics: formatRetryExhaustedDiagnostics({
+                    attempts: attempt,
+                    diagnostics: attemptResult.diagnostics,
+                }),
+                mode,
+                ok: false,
+            };
+        }
+    }
+    throw new Error('Invariant: candidate boot retry loop exited without returning.');
+};
+export const smokeCandidateBoot = async ({ mode = DEFAULT_EQUIV_MODE, workspaceRoot, }) => smokeCandidateBootWithDependencies({
+    mode,
+    workspaceRoot,
+}, {});

package/dist/canonicalize.d.ts

@@ -0,0 +1,19 @@
+type CanonicalizeOptions = {
+    readonly exemptFields?: readonly string[];
+    readonly maxBytes?: number;
+    readonly precision?: number;
+};
+/**
+ * Converts replay values into the stable characterize-compatible wire shape.
+ * `exemptFields` uses dot-notation paths and `maxBytes` aborts once the
+ * canonicalized payload would exceed the configured UTF-8 byte budget.
+ */
+export declare const canonicalize: (value: unknown, options?: CanonicalizeOptions) => unknown;
+/**
+ * Hydrates a canonicalized replay payload back into runtime values for replay.
+ */
+export declare const hydrateCanonicalized: (value: unknown, state?: {
+    refs: Map<number, object>;
+}) => unknown;
+export {};
+//# sourceMappingURL=canonicalize.d.ts.map

package/dist/canonicalize.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"canonicalize.d.ts","sourceRoot":"","sources":["../src/canonicalize.ts"],"names":[],"mappings":"AASA,KAAK,mBAAmB,GAAG;IACvB,QAAQ,CAAC,YAAY,CAAC,EAAE,SAAS,MAAM,EAAE,CAAC;IAC1C,QAAQ,CAAC,QAAQ,CAAC,EAAE,MAAM,CAAC;IAC3B,QAAQ,CAAC,SAAS,CAAC,EAAE,MAAM,CAAC;CAC/B,CAAC;AAsXF;;;;GAIG;AACH,eAAO,MAAM,YAAY,GAAI,OAAO,OAAO,EAAE,UAAS,mBAAwB,KAAG,OAShF,CAAC;AAwNF;;GAEG;AACH,eAAO,MAAM,oBAAoB,GAAI,OAAO,OAAO,EAAE;;CAA8B,KAAG,OAsBrF,CAAC"}