@soundscript/soundscript 0.1.12 → 0.1.15

package/project-transform/src/frontend/sql_macro.js

@@ -0,0 +1,175 @@
+import { findTemplateQuasiAtPosition, findWordAtSourcePosition, formatTemplateLiteralWithInterpolationMarkers, keywordTokenSpans, parseMacroHelperCallExpression, } from './embedded_fragment_support.js';
+const SQL_KEYWORDS = [
+    'as',
+    'delete',
+    'from',
+    'group',
+    'having',
+    'insert',
+    'into',
+    'join',
+    'limit',
+    'offset',
+    'order',
+    'select',
+    'set',
+    'update',
+    'values',
+    'where',
+];
+const SQL_KEYWORD_SET = new Set(SQL_KEYWORDS);
+const SQL_COMPLETIONS = [
+    { label: 'SELECT', detail: 'sql keyword' },
+    { label: 'FROM', detail: 'sql keyword' },
+    { label: 'WHERE', detail: 'sql keyword' },
+    { label: 'INSERT', detail: 'sql keyword' },
+    { label: 'UPDATE', detail: 'sql keyword' },
+    { label: 'DELETE', detail: 'sql keyword' },
+    { label: 'ORDER BY', detail: 'sql keyword' },
+    { label: 'GROUP BY', detail: 'sql keyword' },
+    { label: 'LIMIT', detail: 'sql keyword' },
+];
+function parseSqlInterpolationExpression(text, helperName) {
+    const helperCall = parseMacroHelperCallExpression(text, helperName, ['ident', 'raw']);
+    if (!helperCall) {
+        return { kind: 'bind', expressionText: text };
+    }
+    return {
+        expressionText: helperCall.argumentText,
+        kind: helperCall.helper,
+    };
+}
+function sqlIdentifierExpression(expressionText) {
+    return `('"' + String(${expressionText}).replaceAll('"', '""') + '"')`;
+}
+function buildSqlQueryTextExpression(template, helperName) {
+    const textParts = [];
+    const params = [];
+    let parameterIndex = 1;
+    textParts.push(JSON.stringify(template.quasis[0]?.text ?? ''));
+    for (let index = 0; index < template.expressions.length; index += 1) {
+        const interpolation = parseSqlInterpolationExpression(template.expressions[index].text(), helperName);
+        switch (interpolation.kind) {
+            case 'bind':
+                textParts.push(JSON.stringify(`$${parameterIndex}`));
+                params.push(interpolation.expressionText);
+                parameterIndex += 1;
+                break;
+            case 'ident':
+                textParts.push(sqlIdentifierExpression(interpolation.expressionText));
+                break;
+            case 'raw':
+                textParts.push(`String(${interpolation.expressionText})`);
+                break;
+        }
+        textParts.push(JSON.stringify(template.quasis[index + 1]?.text ?? ''));
+    }
+    return {
+        params,
+        textExpression: textParts.filter((part) => part.length > 0).join(' + ') || '""',
+    };
+}
+const SQL_WORD_REGEX = /\b[A-Za-z_][A-Za-z0-9_]*\b/gu;
+function sqlHover(template, sourcePosition) {
+    const quasi = findTemplateQuasiAtPosition(template, sourcePosition);
+    if (!quasi) {
+        return null;
+    }
+    const word = findWordAtSourcePosition(quasi, sourcePosition, SQL_WORD_REGEX);
+    if (word && SQL_KEYWORD_SET.has(word.word.toLowerCase())) {
+        return {
+            contents: `SQL keyword \`${word.word.toUpperCase()}\`.`,
+        };
+    }
+    return {
+        contents: 'Embedded SQL fragment. `${...}` expressions become bind parameters by default.',
+    };
+}
+function sqlCompletions(template, sourcePosition) {
+    const quasi = findTemplateQuasiAtPosition(template, sourcePosition);
+    if (!quasi) {
+        return [];
+    }
+    const prefix = quasi.text
+        .slice(0, Math.max(0, sourcePosition - quasi.span.start))
+        .match(/[A-Za-z_]*$/u)?.[0] ?? '';
+    const loweredPrefix = prefix.toLowerCase();
+    return SQL_COMPLETIONS.filter((item) => loweredPrefix.length === 0 || item.label.toLowerCase().startsWith(loweredPrefix));
+}
+function formatSqlText(text) {
+    const markerRegex = /__SS_SQL_HOLE_(\d+)__/gu;
+    const compact = text
+        .split('\n')
+        .map((line) => line.trim())
+        .filter((line, index, lines) => line.length > 0 || (index > 0 && index < lines.length - 1))
+        .join('\n')
+        .trim();
+    const uppercasedKeywords = compact.replace(SQL_WORD_REGEX, (word) => SQL_KEYWORD_SET.has(word.toLowerCase()) ? word.toUpperCase() : word);
+    return uppercasedKeywords
+        .split('\n')
+        .map((line, index) => {
+        const normalized = line.replace(/\s+/gu, ' ').trim();
+        if (index === 0) {
+            return normalized;
+        }
+        const upper = normalized.toUpperCase();
+        if (upper.startsWith('FROM ') ||
+            upper.startsWith('WHERE ') ||
+            upper.startsWith('ORDER BY ') ||
+            upper.startsWith('GROUP BY ') ||
+            upper.startsWith('LIMIT ') ||
+            upper.startsWith('OFFSET ') ||
+            upper.startsWith('VALUES ') ||
+            upper.startsWith('SET ') ||
+            upper.startsWith('JOIN ') ||
+            upper.startsWith('HAVING ')) {
+            return `  ${normalized}`;
+        }
+        if (markerRegex.test(normalized)) {
+            markerRegex.lastIndex = 0;
+        }
+        return `  ${normalized}`;
+    })
+        .join('\n');
+}
+function formatSqlTemplateLiteral(template, helperName, formatExpression) {
+    return formatTemplateLiteralWithInterpolationMarkers(template, {
+        expressionTextForIndex(index) {
+            const interpolation = parseSqlInterpolationExpression(template.expressions[index].text(), helperName);
+            return interpolation.kind === 'bind'
+                ? template.expressions[index].text()
+                : `${helperName}.${interpolation.kind}(${interpolation.expressionText})`;
+        },
+        formatCombinedText: formatSqlText,
+        formatExpression,
+        markerPrefix: '__SS_SQL_HOLE_',
+    });
+}
+function createSqlEmbeddedFragment(template, helperName) {
+    return {
+        completions(sourcePosition) {
+            return sqlCompletions(template, sourcePosition);
+        },
+        format(ctx) {
+            return formatSqlTemplateLiteral(template, helperName, ctx.formatExpression);
+        },
+        hover(sourcePosition) {
+            return sqlHover(template, sourcePosition);
+        },
+        language: 'sql',
+        semanticTokens: keywordTokenSpans(template.quasis, SQL_WORD_REGEX, (word) => SQL_KEYWORD_SET.has(word.toLowerCase())),
+        span: template.span,
+    };
+}
+export function sqlFragments(ctx) {
+    const template = ctx.syntax.template(0);
+    return template ? [createSqlEmbeddedFragment(template, ctx.name)] : [];
+}
+export function expandSqlMacro(ctx) {
+    const template = ctx.syntax.template(0);
+    if (!template) {
+        ctx.error('sql requires a template literal operand.');
+    }
+    const { params, textExpression } = buildSqlQueryTextExpression(template, ctx.name);
+    return ctx.output.expr(ctx.quote.expr `({ text: ${textExpression}, params: [${params.join(', ')}] })`);
+}

package/project-transform/src/frontend/sql_macro.ts

@@ -0,0 +1,254 @@
+import type {
+  MacroCompletionItem,
+  MacroContext,
+  MacroEmbeddedFragment,
+  MacroTemplateOperand,
+} from './macro_api.ts';
+import {
+  findTemplateQuasiAtPosition,
+  findWordAtSourcePosition,
+  formatTemplateLiteralWithInterpolationMarkers,
+  keywordTokenSpans,
+  parseMacroHelperCallExpression,
+} from './embedded_fragment_support.ts';
+
+const SQL_KEYWORDS = [
+  'as',
+  'delete',
+  'from',
+  'group',
+  'having',
+  'insert',
+  'into',
+  'join',
+  'limit',
+  'offset',
+  'order',
+  'select',
+  'set',
+  'update',
+  'values',
+  'where',
+] as const;
+
+const SQL_KEYWORD_SET = new Set(SQL_KEYWORDS);
+const SQL_COMPLETIONS: readonly MacroCompletionItem[] = [
+  { label: 'SELECT', detail: 'sql keyword' },
+  { label: 'FROM', detail: 'sql keyword' },
+  { label: 'WHERE', detail: 'sql keyword' },
+  { label: 'INSERT', detail: 'sql keyword' },
+  { label: 'UPDATE', detail: 'sql keyword' },
+  { label: 'DELETE', detail: 'sql keyword' },
+  { label: 'ORDER BY', detail: 'sql keyword' },
+  { label: 'GROUP BY', detail: 'sql keyword' },
+  { label: 'LIMIT', detail: 'sql keyword' },
+] as const;
+
+type SqlInterpolation =
+  | { readonly expressionText: string; readonly kind: 'bind' }
+  | { readonly expressionText: string; readonly kind: 'ident' }
+  | { readonly expressionText: string; readonly kind: 'raw' };
+
+function parseSqlInterpolationExpression(
+  text: string,
+  helperName: string,
+): SqlInterpolation {
+  const helperCall = parseMacroHelperCallExpression(text, helperName, ['ident', 'raw']);
+  if (!helperCall) {
+    return { kind: 'bind', expressionText: text };
+  }
+
+  return {
+    expressionText: helperCall.argumentText,
+    kind: helperCall.helper as 'ident' | 'raw',
+  };
+}
+
+function sqlIdentifierExpression(expressionText: string): string {
+  return `('"' + String(${expressionText}).replaceAll('"', '""') + '"')`;
+}
+
+function buildSqlQueryTextExpression(
+  template: MacroTemplateOperand,
+  helperName: string,
+): { params: readonly string[]; textExpression: string } {
+  const textParts: string[] = [];
+  const params: string[] = [];
+  let parameterIndex = 1;
+
+  textParts.push(JSON.stringify(template.quasis[0]?.text ?? ''));
+  for (let index = 0; index < template.expressions.length; index += 1) {
+    const interpolation = parseSqlInterpolationExpression(
+      template.expressions[index]!.text(),
+      helperName,
+    );
+    switch (interpolation.kind) {
+      case 'bind':
+        textParts.push(JSON.stringify(`$${parameterIndex}`));
+        params.push(interpolation.expressionText);
+        parameterIndex += 1;
+        break;
+      case 'ident':
+        textParts.push(sqlIdentifierExpression(interpolation.expressionText));
+        break;
+      case 'raw':
+        textParts.push(`String(${interpolation.expressionText})`);
+        break;
+    }
+
+    textParts.push(JSON.stringify(template.quasis[index + 1]?.text ?? ''));
+  }
+
+  return {
+    params,
+    textExpression: textParts.filter((part) => part.length > 0).join(' + ') || '""',
+  };
+}
+
+const SQL_WORD_REGEX = /\b[A-Za-z_][A-Za-z0-9_]*\b/gu;
+
+function sqlHover(
+  template: MacroTemplateOperand,
+  sourcePosition: number,
+): { contents: string } | null {
+  const quasi = findTemplateQuasiAtPosition(template, sourcePosition);
+  if (!quasi) {
+    return null;
+  }
+
+  const word = findWordAtSourcePosition(quasi, sourcePosition, SQL_WORD_REGEX);
+  if (word && SQL_KEYWORD_SET.has(word.word.toLowerCase() as typeof SQL_KEYWORDS[number])) {
+    return {
+      contents: `SQL keyword \`${word.word.toUpperCase()}\`.`,
+    };
+  }
+
+  return {
+    contents: 'Embedded SQL fragment. `${...}` expressions become bind parameters by default.',
+  };
+}
+
+function sqlCompletions(
+  template: MacroTemplateOperand,
+  sourcePosition: number,
+): readonly MacroCompletionItem[] {
+  const quasi = findTemplateQuasiAtPosition(template, sourcePosition);
+  if (!quasi) {
+    return [];
+  }
+
+  const prefix = quasi.text
+    .slice(0, Math.max(0, sourcePosition - quasi.span.start))
+    .match(/[A-Za-z_]*$/u)?.[0] ?? '';
+  const loweredPrefix = prefix.toLowerCase();
+  return SQL_COMPLETIONS.filter((item) =>
+    loweredPrefix.length === 0 || item.label.toLowerCase().startsWith(loweredPrefix)
+  );
+}
+
+function formatSqlText(text: string): string {
+  const markerRegex = /__SS_SQL_HOLE_(\d+)__/gu;
+  const compact = text
+    .split('\n')
+    .map((line) => line.trim())
+    .filter((line, index, lines) => line.length > 0 || (index > 0 && index < lines.length - 1))
+    .join('\n')
+    .trim();
+
+  const uppercasedKeywords = compact.replace(SQL_WORD_REGEX, (word) =>
+    SQL_KEYWORD_SET.has(word.toLowerCase() as typeof SQL_KEYWORDS[number]) ? word.toUpperCase() : word
+  );
+
+  return uppercasedKeywords
+    .split('\n')
+    .map((line, index) => {
+      const normalized = line.replace(/\s+/gu, ' ').trim();
+      if (index === 0) {
+        return normalized;
+      }
+
+      const upper = normalized.toUpperCase();
+      if (
+        upper.startsWith('FROM ') ||
+        upper.startsWith('WHERE ') ||
+        upper.startsWith('ORDER BY ') ||
+        upper.startsWith('GROUP BY ') ||
+        upper.startsWith('LIMIT ') ||
+        upper.startsWith('OFFSET ') ||
+        upper.startsWith('VALUES ') ||
+        upper.startsWith('SET ') ||
+        upper.startsWith('JOIN ') ||
+        upper.startsWith('HAVING ')
+      ) {
+        return `  ${normalized}`;
+      }
+
+      if (markerRegex.test(normalized)) {
+        markerRegex.lastIndex = 0;
+      }
+      return `  ${normalized}`;
+    })
+    .join('\n');
+}
+
+function formatSqlTemplateLiteral(
+  template: MacroTemplateOperand,
+  helperName: string,
+  formatExpression: (text: string) => string,
+): string {
+  return formatTemplateLiteralWithInterpolationMarkers(template, {
+    expressionTextForIndex(index) {
+      const interpolation = parseSqlInterpolationExpression(
+        template.expressions[index]!.text(),
+        helperName,
+      );
+      return interpolation.kind === 'bind'
+        ? template.expressions[index]!.text()
+        : `${helperName}.${interpolation.kind}(${interpolation.expressionText})`;
+    },
+    formatCombinedText: formatSqlText,
+    formatExpression,
+    markerPrefix: '__SS_SQL_HOLE_',
+  });
+}
+
+function createSqlEmbeddedFragment(
+  template: MacroTemplateOperand,
+  helperName: string,
+): MacroEmbeddedFragment {
+  return {
+    completions(sourcePosition) {
+      return sqlCompletions(template, sourcePosition);
+    },
+    format(ctx) {
+      return formatSqlTemplateLiteral(template, helperName, ctx.formatExpression);
+    },
+    hover(sourcePosition) {
+      return sqlHover(template, sourcePosition);
+    },
+    language: 'sql',
+    semanticTokens: keywordTokenSpans(
+      template.quasis,
+      SQL_WORD_REGEX,
+      (word) => SQL_KEYWORD_SET.has(word.toLowerCase() as typeof SQL_KEYWORDS[number]),
+    ),
+    span: template.span,
+  };
+}
+
+export function sqlFragments(ctx: MacroContext): readonly MacroEmbeddedFragment[] {
+  const template = ctx.syntax.template(0);
+  return template ? [createSqlEmbeddedFragment(template, ctx.name)] : [];
+}
+
+export function expandSqlMacro(ctx: MacroContext) {
+  const template = ctx.syntax.template(0);
+  if (!template) {
+    ctx.error('sql requires a template literal operand.');
+  }
+
+  const { params, textExpression } = buildSqlQueryTextExpression(template, ctx.name);
+  return ctx.output.expr(
+    ctx.quote.expr`({ text: ${textExpression}, params: [${params.join(', ')}] })`,
+  );
+}

package/project-transform/src/frontend/sql_stdlib_support.js

@@ -0,0 +1 @@
+export { SQL_STDLIB_DECLARATION_FILE, SQL_STDLIB_DECLARATION_TEXT, SQL_STDLIB_MODULE_SPECIFIER, withStdPackageModuleResolution as withSqlStdlibModuleResolution, } from './std_package_support.js';

package/project-transform/src/frontend/sql_stdlib_support.ts

@@ -0,0 +1,6 @@
+export {
+  SQL_STDLIB_DECLARATION_FILE,
+  SQL_STDLIB_DECLARATION_TEXT,
+  SQL_STDLIB_MODULE_SPECIFIER,
+  withStdPackageModuleResolution as withSqlStdlibModuleResolution,
+} from './std_package_support.ts';

package/project-transform/src/frontend/std_package_support.js

@@ -0,0 +1,228 @@
+import ts from 'typescript';
+import { STS_ASYNC_MODULE_SPECIFIER, STS_CODEC_MODULE_SPECIFIER, STS_COMPARE_MODULE_SPECIFIER, STS_DECODE_MODULE_SPECIFIER, STS_DERIVE_MODULE_SPECIFIER, STS_ENCODE_MODULE_SPECIFIER, STS_EXPERIMENTAL_COMPONENT_MODULE_SPECIFIER, STS_EXPERIMENTAL_CSS_MODULE_SPECIFIER, STS_EXPERIMENTAL_DEBUG_MODULE_SPECIFIER, STS_EXPERIMENTAL_GRAPHQL_MODULE_SPECIFIER, STS_EXPERIMENTAL_SQL_MODULE_SPECIFIER, STS_FAILURES_MODULE_SPECIFIER, STS_FETCH_MODULE_SPECIFIER, STS_HASH_MODULE_SPECIFIER, STS_HKT_MODULE_SPECIFIER, STS_JSON_MODULE_SPECIFIER, STS_MATCH_MODULE_SPECIFIER, STS_NUMERICS_MODULE_SPECIFIER, STS_PRELUDE_MODULE_SPECIFIER, STS_RANDOM_MODULE_SPECIFIER, STS_RESULT_MODULE_SPECIFIER, STS_TEXT_MODULE_SPECIFIER, STS_THUNK_MODULE_SPECIFIER, STS_TYPECLASSES_MODULE_SPECIFIER, STS_URL_MODULE_SPECIFIER, STS_VALUE_MODULE_SPECIFIER, } from '../soundscript_runtime_specifiers.js';
+import { fileExistsSync, readTextFileSync, runtimeExecPath } from '../platform/host.js';
+import { basename, dirname, fromFileUrl, join } from '../platform/path.js';
+export const STDLIB_MODULE_SPECIFIER = STS_PRELUDE_MODULE_SPECIFIER;
+export const HKT_STDLIB_MODULE_SPECIFIER = STS_HKT_MODULE_SPECIFIER;
+export const TYPECLASSES_STDLIB_MODULE_SPECIFIER = STS_TYPECLASSES_MODULE_SPECIFIER;
+export const RESULT_STDLIB_MODULE_SPECIFIER = STS_RESULT_MODULE_SPECIFIER;
+export const VALUE_STDLIB_MODULE_SPECIFIER = STS_VALUE_MODULE_SPECIFIER;
+export const MATCH_STDLIB_MODULE_SPECIFIER = STS_MATCH_MODULE_SPECIFIER;
+export const FAILURES_STDLIB_MODULE_SPECIFIER = STS_FAILURES_MODULE_SPECIFIER;
+export const URL_STDLIB_MODULE_SPECIFIER = STS_URL_MODULE_SPECIFIER;
+export const FETCH_STDLIB_MODULE_SPECIFIER = STS_FETCH_MODULE_SPECIFIER;
+export const TEXT_STDLIB_MODULE_SPECIFIER = STS_TEXT_MODULE_SPECIFIER;
+export const RANDOM_STDLIB_MODULE_SPECIFIER = STS_RANDOM_MODULE_SPECIFIER;
+export const JSON_STDLIB_MODULE_SPECIFIER = STS_JSON_MODULE_SPECIFIER;
+export const COMPARE_STDLIB_MODULE_SPECIFIER = STS_COMPARE_MODULE_SPECIFIER;
+export const HASH_STDLIB_MODULE_SPECIFIER = STS_HASH_MODULE_SPECIFIER;
+export const DERIVE_STDLIB_MODULE_SPECIFIER = STS_DERIVE_MODULE_SPECIFIER;
+export const DECODE_STDLIB_MODULE_SPECIFIER = STS_DECODE_MODULE_SPECIFIER;
+export const ENCODE_STDLIB_MODULE_SPECIFIER = STS_ENCODE_MODULE_SPECIFIER;
+export const CODEC_STDLIB_MODULE_SPECIFIER = STS_CODEC_MODULE_SPECIFIER;
+export const ASYNC_STDLIB_MODULE_SPECIFIER = STS_ASYNC_MODULE_SPECIFIER;
+export const THUNK_STDLIB_MODULE_SPECIFIER = STS_THUNK_MODULE_SPECIFIER;
+export const SQL_STDLIB_MODULE_SPECIFIER = STS_EXPERIMENTAL_SQL_MODULE_SPECIFIER;
+export const CSS_STDLIB_MODULE_SPECIFIER = STS_EXPERIMENTAL_CSS_MODULE_SPECIFIER;
+export const GRAPHQL_STDLIB_MODULE_SPECIFIER = STS_EXPERIMENTAL_GRAPHQL_MODULE_SPECIFIER;
+export const COMPONENT_STDLIB_MODULE_SPECIFIER = STS_EXPERIMENTAL_COMPONENT_MODULE_SPECIFIER;
+export const DEBUG_STDLIB_MODULE_SPECIFIER = STS_EXPERIMENTAL_DEBUG_MODULE_SPECIFIER;
+export const NUMERICS_STDLIB_MODULE_SPECIFIER = STS_NUMERICS_MODULE_SPECIFIER;
+export const STDLIB_DECLARATION_FILE = fromFileUrl(new URL('../stdlib/index.d.ts', import.meta.url));
+export const HKT_STDLIB_DECLARATION_FILE = fromFileUrl(new URL('../stdlib/hkt.d.ts', import.meta.url));
+export const TYPECLASSES_STDLIB_DECLARATION_FILE = fromFileUrl(new URL('../stdlib/typeclasses.d.ts', import.meta.url));
+export const RESULT_STDLIB_DECLARATION_FILE = fromFileUrl(new URL('../stdlib/result.d.ts', import.meta.url));
+export const VALUE_STDLIB_DECLARATION_FILE = fromFileUrl(new URL('../stdlib/value.d.ts', import.meta.url));
+export const MATCH_STDLIB_DECLARATION_FILE = fromFileUrl(new URL('../stdlib/match.d.ts', import.meta.url));
+export const FAILURES_STDLIB_DECLARATION_FILE = fromFileUrl(new URL('../stdlib/failures.d.ts', import.meta.url));
+export const URL_STDLIB_DECLARATION_FILE = fromFileUrl(new URL('../stdlib/url.d.ts', import.meta.url));
+export const FETCH_STDLIB_DECLARATION_FILE = fromFileUrl(new URL('../stdlib/fetch.d.ts', import.meta.url));
+export const TEXT_STDLIB_DECLARATION_FILE = fromFileUrl(new URL('../stdlib/text.d.ts', import.meta.url));
+export const RANDOM_STDLIB_DECLARATION_FILE = fromFileUrl(new URL('../stdlib/random.d.ts', import.meta.url));
+export const JSON_STDLIB_DECLARATION_FILE = fromFileUrl(new URL('../stdlib/json.d.ts', import.meta.url));
+export const COMPARE_STDLIB_DECLARATION_FILE = fromFileUrl(new URL('../stdlib/compare.d.ts', import.meta.url));
+export const HASH_STDLIB_DECLARATION_FILE = fromFileUrl(new URL('../stdlib/hash.d.ts', import.meta.url));
+export const DERIVE_STDLIB_DECLARATION_FILE = fromFileUrl(new URL('../stdlib/derive.d.ts', import.meta.url));
+export const DECODE_STDLIB_DECLARATION_FILE = fromFileUrl(new URL('../stdlib/decode.d.ts', import.meta.url));
+export const ENCODE_STDLIB_DECLARATION_FILE = fromFileUrl(new URL('../stdlib/encode.d.ts', import.meta.url));
+export const CODEC_STDLIB_DECLARATION_FILE = fromFileUrl(new URL('../stdlib/codec.d.ts', import.meta.url));
+export const ASYNC_STDLIB_DECLARATION_FILE = fromFileUrl(new URL('../stdlib/async.d.ts', import.meta.url));
+export const THUNK_STDLIB_DECLARATION_FILE = fromFileUrl(new URL('../stdlib/thunk.d.ts', import.meta.url));
+export const SQL_STDLIB_DECLARATION_FILE = fromFileUrl(new URL('../stdlib/sql.d.ts', import.meta.url));
+export const CSS_STDLIB_DECLARATION_FILE = fromFileUrl(new URL('../stdlib/css.d.ts', import.meta.url));
+export const GRAPHQL_STDLIB_DECLARATION_FILE = fromFileUrl(new URL('../stdlib/graphql.d.ts', import.meta.url));
+export const COMPONENT_STDLIB_DECLARATION_FILE = fromFileUrl(new URL('../stdlib/component.d.ts', import.meta.url));
+export const DEBUG_STDLIB_DECLARATION_FILE = fromFileUrl(new URL('../stdlib/debug.d.ts', import.meta.url));
+export const NUMERICS_STDLIB_DECLARATION_FILE = fromFileUrl(new URL('../stdlib/numerics.d.ts', import.meta.url));
+function fileExists(path) {
+    return fileExistsSync(path);
+}
+export function resolveStdlibDeclarationRuntimePath(sourceFilePath, { execPath = runtimeExecPath(), } = {}) {
+    const fileName = basename(sourceFilePath);
+    const candidatePaths = [
+        sourceFilePath,
+        join(dirname(execPath), '..', 'src', 'stdlib', fileName),
+    ];
+    for (const candidatePath of candidatePaths) {
+        if (fileExists(candidatePath)) {
+            return candidatePath;
+        }
+    }
+    return sourceFilePath;
+}
+function readStdlibDeclarationText(sourceFilePath) {
+    const resolvedPath = resolveStdlibDeclarationRuntimePath(sourceFilePath);
+    const overrideTexts = globalThis
+        .__STS_STDLIB_DECLARATION_TEXTS__;
+    const overrideText = overrideTexts?.[sourceFilePath] ??
+        overrideTexts?.[resolvedPath] ??
+        overrideTexts?.[basename(sourceFilePath)];
+    if (overrideText !== undefined) {
+        return overrideText;
+    }
+    return readTextFileSync(resolvedPath);
+}
+export const STDLIB_DECLARATION_TEXT = readStdlibDeclarationText(STDLIB_DECLARATION_FILE);
+export const HKT_STDLIB_DECLARATION_TEXT = readStdlibDeclarationText(HKT_STDLIB_DECLARATION_FILE);
+export const TYPECLASSES_STDLIB_DECLARATION_TEXT = readStdlibDeclarationText(TYPECLASSES_STDLIB_DECLARATION_FILE);
+export const RESULT_STDLIB_DECLARATION_TEXT = readStdlibDeclarationText(RESULT_STDLIB_DECLARATION_FILE);
+export const VALUE_STDLIB_DECLARATION_TEXT = readStdlibDeclarationText(VALUE_STDLIB_DECLARATION_FILE);
+export const MATCH_STDLIB_DECLARATION_TEXT = readStdlibDeclarationText(MATCH_STDLIB_DECLARATION_FILE);
+export const FAILURES_STDLIB_DECLARATION_TEXT = readStdlibDeclarationText(FAILURES_STDLIB_DECLARATION_FILE);
+export const URL_STDLIB_DECLARATION_TEXT = readStdlibDeclarationText(URL_STDLIB_DECLARATION_FILE);
+export const FETCH_STDLIB_DECLARATION_TEXT = readStdlibDeclarationText(FETCH_STDLIB_DECLARATION_FILE);
+export const TEXT_STDLIB_DECLARATION_TEXT = readStdlibDeclarationText(TEXT_STDLIB_DECLARATION_FILE);
+export const RANDOM_STDLIB_DECLARATION_TEXT = readStdlibDeclarationText(RANDOM_STDLIB_DECLARATION_FILE);
+export const JSON_STDLIB_DECLARATION_TEXT = readStdlibDeclarationText(JSON_STDLIB_DECLARATION_FILE);
+export const COMPARE_STDLIB_DECLARATION_TEXT = readStdlibDeclarationText(COMPARE_STDLIB_DECLARATION_FILE);
+export const HASH_STDLIB_DECLARATION_TEXT = readStdlibDeclarationText(HASH_STDLIB_DECLARATION_FILE);
+export const DERIVE_STDLIB_DECLARATION_TEXT = readStdlibDeclarationText(DERIVE_STDLIB_DECLARATION_FILE);
+export const DECODE_STDLIB_DECLARATION_TEXT = readStdlibDeclarationText(DECODE_STDLIB_DECLARATION_FILE);
+export const ENCODE_STDLIB_DECLARATION_TEXT = readStdlibDeclarationText(ENCODE_STDLIB_DECLARATION_FILE);
+export const CODEC_STDLIB_DECLARATION_TEXT = readStdlibDeclarationText(CODEC_STDLIB_DECLARATION_FILE);
+export const ASYNC_STDLIB_DECLARATION_TEXT = readStdlibDeclarationText(ASYNC_STDLIB_DECLARATION_FILE);
+export const THUNK_STDLIB_DECLARATION_TEXT = readStdlibDeclarationText(THUNK_STDLIB_DECLARATION_FILE);
+export const SQL_STDLIB_DECLARATION_TEXT = readStdlibDeclarationText(SQL_STDLIB_DECLARATION_FILE);
+export const CSS_STDLIB_DECLARATION_TEXT = readStdlibDeclarationText(CSS_STDLIB_DECLARATION_FILE);
+export const GRAPHQL_STDLIB_DECLARATION_TEXT = readStdlibDeclarationText(GRAPHQL_STDLIB_DECLARATION_FILE);
+export const COMPONENT_STDLIB_DECLARATION_TEXT = fileExists(COMPONENT_STDLIB_DECLARATION_FILE)
+    ? readStdlibDeclarationText(COMPONENT_STDLIB_DECLARATION_FILE)
+    : undefined;
+export const DEBUG_STDLIB_DECLARATION_TEXT = readStdlibDeclarationText(DEBUG_STDLIB_DECLARATION_FILE);
+export const NUMERICS_STDLIB_DECLARATION_TEXT = readStdlibDeclarationText(NUMERICS_STDLIB_DECLARATION_FILE);
+const STDLIB_DECLARATION_FILES = new Map([
+    [STDLIB_MODULE_SPECIFIER, STDLIB_DECLARATION_FILE],
+    [HKT_STDLIB_MODULE_SPECIFIER, HKT_STDLIB_DECLARATION_FILE],
+    [TYPECLASSES_STDLIB_MODULE_SPECIFIER, TYPECLASSES_STDLIB_DECLARATION_FILE],
+    [RESULT_STDLIB_MODULE_SPECIFIER, RESULT_STDLIB_DECLARATION_FILE],
+    [VALUE_STDLIB_MODULE_SPECIFIER, VALUE_STDLIB_DECLARATION_FILE],
+    [MATCH_STDLIB_MODULE_SPECIFIER, MATCH_STDLIB_DECLARATION_FILE],
+    [FAILURES_STDLIB_MODULE_SPECIFIER, FAILURES_STDLIB_DECLARATION_FILE],
+    [URL_STDLIB_MODULE_SPECIFIER, URL_STDLIB_DECLARATION_FILE],
+    [FETCH_STDLIB_MODULE_SPECIFIER, FETCH_STDLIB_DECLARATION_FILE],
+    [TEXT_STDLIB_MODULE_SPECIFIER, TEXT_STDLIB_DECLARATION_FILE],
+    [RANDOM_STDLIB_MODULE_SPECIFIER, RANDOM_STDLIB_DECLARATION_FILE],
+    [JSON_STDLIB_MODULE_SPECIFIER, JSON_STDLIB_DECLARATION_FILE],
+    [COMPARE_STDLIB_MODULE_SPECIFIER, COMPARE_STDLIB_DECLARATION_FILE],
+    [HASH_STDLIB_MODULE_SPECIFIER, HASH_STDLIB_DECLARATION_FILE],
+    [DERIVE_STDLIB_MODULE_SPECIFIER, DERIVE_STDLIB_DECLARATION_FILE],
+    [DECODE_STDLIB_MODULE_SPECIFIER, DECODE_STDLIB_DECLARATION_FILE],
+    [ENCODE_STDLIB_MODULE_SPECIFIER, ENCODE_STDLIB_DECLARATION_FILE],
+    [CODEC_STDLIB_MODULE_SPECIFIER, CODEC_STDLIB_DECLARATION_FILE],
+    [ASYNC_STDLIB_MODULE_SPECIFIER, ASYNC_STDLIB_DECLARATION_FILE],
+    [THUNK_STDLIB_MODULE_SPECIFIER, THUNK_STDLIB_DECLARATION_FILE],
+    [SQL_STDLIB_MODULE_SPECIFIER, SQL_STDLIB_DECLARATION_FILE],
+    [CSS_STDLIB_MODULE_SPECIFIER, CSS_STDLIB_DECLARATION_FILE],
+    [GRAPHQL_STDLIB_MODULE_SPECIFIER, GRAPHQL_STDLIB_DECLARATION_FILE],
+    ...(COMPONENT_STDLIB_DECLARATION_TEXT === undefined
+        ? []
+        : [[COMPONENT_STDLIB_MODULE_SPECIFIER, COMPONENT_STDLIB_DECLARATION_FILE]]),
+    [DEBUG_STDLIB_MODULE_SPECIFIER, DEBUG_STDLIB_DECLARATION_FILE],
+    [NUMERICS_STDLIB_MODULE_SPECIFIER, NUMERICS_STDLIB_DECLARATION_FILE],
+]);
+const STDLIB_DECLARATION_FILE_SET = new Set(STDLIB_DECLARATION_FILES.values());
+const STDLIB_DECLARATION_TEXTS = new Map([
+    [STDLIB_DECLARATION_FILE, STDLIB_DECLARATION_TEXT],
+    [HKT_STDLIB_DECLARATION_FILE, HKT_STDLIB_DECLARATION_TEXT],
+    [TYPECLASSES_STDLIB_DECLARATION_FILE, TYPECLASSES_STDLIB_DECLARATION_TEXT],
+    [RESULT_STDLIB_DECLARATION_FILE, RESULT_STDLIB_DECLARATION_TEXT],
+    [VALUE_STDLIB_DECLARATION_FILE, VALUE_STDLIB_DECLARATION_TEXT],
+    [MATCH_STDLIB_DECLARATION_FILE, MATCH_STDLIB_DECLARATION_TEXT],
+    [FAILURES_STDLIB_DECLARATION_FILE, FAILURES_STDLIB_DECLARATION_TEXT],
+    [URL_STDLIB_DECLARATION_FILE, URL_STDLIB_DECLARATION_TEXT],
+    [FETCH_STDLIB_DECLARATION_FILE, FETCH_STDLIB_DECLARATION_TEXT],
+    [TEXT_STDLIB_DECLARATION_FILE, TEXT_STDLIB_DECLARATION_TEXT],
+    [RANDOM_STDLIB_DECLARATION_FILE, RANDOM_STDLIB_DECLARATION_TEXT],
+    [JSON_STDLIB_DECLARATION_FILE, JSON_STDLIB_DECLARATION_TEXT],
+    [COMPARE_STDLIB_DECLARATION_FILE, COMPARE_STDLIB_DECLARATION_TEXT],
+    [HASH_STDLIB_DECLARATION_FILE, HASH_STDLIB_DECLARATION_TEXT],
+    [DERIVE_STDLIB_DECLARATION_FILE, DERIVE_STDLIB_DECLARATION_TEXT],
+    [DECODE_STDLIB_DECLARATION_FILE, DECODE_STDLIB_DECLARATION_TEXT],
+    [ENCODE_STDLIB_DECLARATION_FILE, ENCODE_STDLIB_DECLARATION_TEXT],
+    [CODEC_STDLIB_DECLARATION_FILE, CODEC_STDLIB_DECLARATION_TEXT],
+    [ASYNC_STDLIB_DECLARATION_FILE, ASYNC_STDLIB_DECLARATION_TEXT],
+    [THUNK_STDLIB_DECLARATION_FILE, THUNK_STDLIB_DECLARATION_TEXT],
+    [SQL_STDLIB_DECLARATION_FILE, SQL_STDLIB_DECLARATION_TEXT],
+    [CSS_STDLIB_DECLARATION_FILE, CSS_STDLIB_DECLARATION_TEXT],
+    [GRAPHQL_STDLIB_DECLARATION_FILE, GRAPHQL_STDLIB_DECLARATION_TEXT],
+    ...(COMPONENT_STDLIB_DECLARATION_TEXT === undefined
+        ? []
+        : [[COMPONENT_STDLIB_DECLARATION_FILE, COMPONENT_STDLIB_DECLARATION_TEXT]]),
+    [DEBUG_STDLIB_DECLARATION_FILE, DEBUG_STDLIB_DECLARATION_TEXT],
+    [NUMERICS_STDLIB_DECLARATION_FILE, NUMERICS_STDLIB_DECLARATION_TEXT],
+]);
+const STDLIB_DECLARATION_ENTRIES_BY_SPECIFIER = new Map([...STDLIB_DECLARATION_FILES.entries()].flatMap(([specifier, fileName]) => {
+    const text = STDLIB_DECLARATION_TEXTS.get(fileName);
+    return text === undefined ? [] : [[specifier, { fileName, text }]];
+}));
+export function getStdlibDeclarationTexts() {
+    return STDLIB_DECLARATION_TEXTS;
+}
+export function getStdlibDeclarationEntriesBySpecifier() {
+    return STDLIB_DECLARATION_ENTRIES_BY_SPECIFIER;
+}
+function createModuleResolutionHost(baseHost) {
+    return {
+        directoryExists: baseHost.directoryExists?.bind(baseHost),
+        fileExists: baseHost.fileExists.bind(baseHost),
+        getCurrentDirectory: baseHost.getCurrentDirectory?.bind(baseHost) ??
+            (() => ts.sys.getCurrentDirectory()),
+        getDirectories: baseHost.getDirectories?.bind(baseHost),
+        readFile: baseHost.readFile.bind(baseHost),
+        realpath: baseHost.realpath?.bind(baseHost),
+        useCaseSensitiveFileNames: () => ts.sys.useCaseSensitiveFileNames,
+    };
+}
+export function withStdPackageModuleResolution(baseHost) {
+    return {
+        ...baseHost,
+        fileExists(fileName) {
+            return STDLIB_DECLARATION_FILE_SET.has(fileName) || baseHost.fileExists(fileName);
+        },
+        readFile(fileName) {
+            if (STDLIB_DECLARATION_FILE_SET.has(fileName)) {
+                return STDLIB_DECLARATION_TEXTS.get(fileName);
+            }
+            return baseHost.readFile(fileName);
+        },
+        resolveModuleNames(moduleNames, containingFile, reusedNames, redirectedReference, options) {
+            const fallbackHost = createModuleResolutionHost(baseHost);
+            const delegated = baseHost.resolveModuleNames?.(moduleNames, containingFile, reusedNames, redirectedReference, options ?? {});
+            return moduleNames.map((moduleName, index) => {
+                const stdlibDeclarationFile = STDLIB_DECLARATION_FILES.get(moduleName);
+                if (stdlibDeclarationFile) {
+                    return {
+                        resolvedFileName: stdlibDeclarationFile,
+                        extension: ts.Extension.Dts,
+                        isExternalLibraryImport: true,
+                    };
+                }
+                if (delegated?.[index]) {
+                    return delegated[index];
+                }
+                const resolved = ts.resolveModuleName(moduleName, containingFile, options ?? {}, fallbackHost, undefined, redirectedReference);
+                return resolved.resolvedModule;
+            });
+        },
+    };
+}