@terrazzo/parser 2.0.0-alpha.7 → 2.0.0-beta.0

package/src/lint/plugin-core/rules/valid-shadow.ts

@@ -1,67 +0,0 @@
-import type * as momoa from '@humanwhocodes/momoa';
-import { getObjMember } from '@terrazzo/json-schema-tools';
-import { SHADOW_REQUIRED_PROPERTIES } from '@terrazzo/token-tools';
-import type { LintRule } from '../../../types.js';
-import { docsLink } from '../lib/docs.js';
-
-export const VALID_SHADOW = 'core/valid-shadow';
-
-const ERROR = 'ERROR';
-const ERROR_INVALID_PROP = 'ERROR_INVALID_PROP';
-
-const rule: LintRule<typeof ERROR | typeof ERROR_INVALID_PROP> = {
-  meta: {
-    messages: {
-      [ERROR]: `Missing required properties: ${new Intl.ListFormat('en-us', { type: 'conjunction' }).format(SHADOW_REQUIRED_PROPERTIES)}.`,
-      [ERROR_INVALID_PROP]: 'Unknown property {{ key }}.',
-    },
-    docs: {
-      description: 'Require shadow tokens to follow the format.',
-      url: docsLink(VALID_SHADOW),
-    },
-  },
-  defaultOptions: {},
-  create({ tokens, report }) {
-    for (const t of Object.values(tokens)) {
-      if (t.aliasOf || !t.originalValue || t.$type !== 'shadow') {
-        continue;
-      }
-
-      validateShadow(t.originalValue.$value, {
-        node: getObjMember(t.source.node, '$value') as momoa.ObjectNode,
-        filename: t.source.filename,
-      });
-
-      // Note: we validate sub-properties using other checks like valid-dimension, valid-font-family, etc.
-      // The only thing remaining is to check that all properties exist (since missing properties won’t appear as invalid)
-      function validateShadow(
-        value: unknown,
-        { node, filename }: { node: momoa.ObjectNode | momoa.ArrayNode; filename?: string },
-      ) {
-        const wrappedValue = Array.isArray(value) ? value : [value];
-        for (let i = 0; i < wrappedValue.length; i++) {
-          if (
-            !wrappedValue[i] ||
-            typeof wrappedValue[i] !== 'object' ||
-            !SHADOW_REQUIRED_PROPERTIES.every((property) => property in wrappedValue[i])
-          ) {
-            report({ messageId: ERROR, node, filename });
-          } else {
-            for (const key of Object.keys(wrappedValue[i])) {
-              if (![...SHADOW_REQUIRED_PROPERTIES, 'inset'].includes(key)) {
-                report({
-                  messageId: ERROR_INVALID_PROP,
-                  data: { key: JSON.stringify(key) },
-                  node: getObjMember(node.type === 'Array' ? (node.elements[i]!.value as momoa.ObjectNode) : node, key),
-                  filename,
-                });
-              }
-            }
-          }
-        }
-      }
-    }
-  },
-};
-
-export default rule;

package/src/lint/plugin-core/rules/valid-string.ts

@@ -1,41 +0,0 @@
-import type * as momoa from '@humanwhocodes/momoa';
-import { getObjMember } from '@terrazzo/json-schema-tools';
-import type { LintRule } from '../../../types.js';
-import { docsLink } from '../lib/docs.js';
-
-export const VALID_STRING = 'core/valid-string';
-
-const ERROR = 'ERROR';
-
-const rule: LintRule<typeof ERROR> = {
-  meta: {
-    messages: {
-      [ERROR]: 'Must be a string.',
-    },
-    docs: {
-      description: 'Require string tokens to follow the Terrazzo extension.',
-      url: docsLink(VALID_STRING),
-    },
-  },
-  defaultOptions: {},
-  create({ tokens, report }) {
-    for (const t of Object.values(tokens)) {
-      if (t.aliasOf || !t.originalValue || t.$type !== 'string') {
-        continue;
-      }
-
-      validateString(t.originalValue.$value, {
-        node: getObjMember(t.source.node, '$value') as momoa.StringNode,
-        filename: t.source.filename,
-      });
-
-      function validateString(value: unknown, { node, filename }: { node: momoa.StringNode; filename?: string }) {
-        if (typeof value !== 'string') {
-          report({ messageId: ERROR, node, filename });
-        }
-      }
-    }
-  },
-};
-
-export default rule;

package/src/lint/plugin-core/rules/valid-stroke-style.ts

@@ -1,104 +0,0 @@
-import type * as momoa from '@humanwhocodes/momoa';
-import { getObjMember } from '@terrazzo/json-schema-tools';
-import {
-  isAlias,
-  STROKE_STYLE_LINE_CAP_VALUES,
-  STROKE_STYLE_OBJECT_REQUIRED_PROPERTIES,
-  STROKE_STYLE_STRING_VALUES,
-  TRANSITION_REQUIRED_PROPERTIES,
-} from '@terrazzo/token-tools';
-import type { LintRule } from '../../../types.js';
-import { docsLink } from '../lib/docs.js';
-
-export const VALID_STROKE_STYLE = 'core/valid-stroke-style';
-
-const ERROR_STR = 'ERROR_STR';
-const ERROR_OBJ = 'ERROR_OBJ';
-const ERROR_LINE_CAP = 'ERROR_LINE_CAP';
-const ERROR_INVALID_PROP = 'ERROR_INVALID_PROP';
-
-const rule: LintRule<typeof ERROR_STR | typeof ERROR_OBJ | typeof ERROR_LINE_CAP | typeof ERROR_INVALID_PROP> = {
-  meta: {
-    messages: {
-      [ERROR_STR]: `Value most be one of ${new Intl.ListFormat('en-us', { type: 'disjunction' }).format(STROKE_STYLE_STRING_VALUES)}.`,
-      [ERROR_OBJ]: `Missing required properties: ${new Intl.ListFormat('en-us', { type: 'conjunction' }).format(TRANSITION_REQUIRED_PROPERTIES)}.`,
-      [ERROR_LINE_CAP]: `lineCap must be one of ${new Intl.ListFormat('en-us', { type: 'disjunction' }).format(STROKE_STYLE_LINE_CAP_VALUES)}.`,
-      [ERROR_INVALID_PROP]: 'Unknown property: {{ key }}.',
-    },
-    docs: {
-      description: 'Require strokeStyle tokens to follow the format.',
-      url: docsLink(VALID_STROKE_STYLE),
-    },
-  },
-  defaultOptions: {},
-  create({ tokens, report }) {
-    for (const t of Object.values(tokens)) {
-      if (t.aliasOf || !t.originalValue) {
-        continue;
-      }
-
-      switch (t.$type) {
-        case 'strokeStyle': {
-          validateStrokeStyle(t.originalValue.$value, {
-            node: getObjMember(t.source.node, '$value') as momoa.ObjectNode,
-            filename: t.source.filename,
-          });
-          break;
-        }
-        case 'border': {
-          if (t.originalValue.$value && typeof t.originalValue.$value === 'object') {
-            const $valueNode = getObjMember(t.source.node, '$value') as momoa.ObjectNode;
-            if (t.originalValue.$value.style) {
-              validateStrokeStyle(t.originalValue.$value.style, {
-                node: getObjMember($valueNode, 'style') as momoa.ObjectNode,
-                filename: t.source.filename,
-              });
-            }
-          }
-          break;
-        }
-      }
-
-      // Note: we validate sub-properties using other checks like valid-dimension, valid-font-family, etc.
-      // The only thing remaining is to check that all properties exist (since missing properties won’t appear as invalid)
-      function validateStrokeStyle(
-        value: unknown,
-        { node, filename }: { node: momoa.StringNode | momoa.ObjectNode; filename?: string },
-      ) {
-        if (typeof value === 'string') {
-          if (
-            !isAlias(value) &&
-            !STROKE_STYLE_STRING_VALUES.includes(value as (typeof STROKE_STYLE_STRING_VALUES)[number])
-          ) {
-            report({ messageId: ERROR_STR, node, filename });
-            return;
-          }
-        } else if (value && typeof value === 'object') {
-          if (!STROKE_STYLE_OBJECT_REQUIRED_PROPERTIES.every((property) => property in value)) {
-            report({ messageId: ERROR_OBJ, node, filename });
-          }
-          if (!Array.isArray((value as any).dashArray)) {
-            report({ messageId: ERROR_OBJ, node: getObjMember(node as momoa.ObjectNode, 'dashArray'), filename });
-          }
-          if (!STROKE_STYLE_LINE_CAP_VALUES.includes((value as any).lineCap)) {
-            report({ messageId: ERROR_OBJ, node: getObjMember(node as momoa.ObjectNode, 'lineCap'), filename });
-          }
-          for (const key of Object.keys(value)) {
-            if (!['dashArray', 'lineCap'].includes(key)) {
-              report({
-                messageId: ERROR_INVALID_PROP,
-                data: { key: JSON.stringify(key) },
-                node: getObjMember(node as momoa.ObjectNode, key),
-                filename,
-              });
-            }
-          }
-        } else {
-          report({ messageId: ERROR_OBJ, node, filename });
-        }
-      }
-    }
-  },
-};
-
-export default rule;

package/src/lint/plugin-core/rules/valid-transition.ts

@@ -1,61 +0,0 @@
-import type * as momoa from '@humanwhocodes/momoa';
-import { getObjMember } from '@terrazzo/json-schema-tools';
-import { TRANSITION_REQUIRED_PROPERTIES } from '@terrazzo/token-tools';
-import type { LintRule } from '../../../types.js';
-import { docsLink } from '../lib/docs.js';
-
-export const VALID_TRANSITION = 'core/valid-transition';
-
-const ERROR = 'ERROR';
-const ERROR_INVALID_PROP = 'ERROR_INVALID_PROP';
-
-const rule: LintRule<typeof ERROR | typeof ERROR_INVALID_PROP> = {
-  meta: {
-    messages: {
-      [ERROR]: `Missing required properties: ${new Intl.ListFormat('en-us', { type: 'conjunction' }).format(TRANSITION_REQUIRED_PROPERTIES)}.`,
-      [ERROR_INVALID_PROP]: 'Unknown property: {{ key }}.',
-    },
-    docs: {
-      description: 'Require transition tokens to follow the format.',
-      url: docsLink(VALID_TRANSITION),
-    },
-  },
-  defaultOptions: {},
-  create({ tokens, report }) {
-    for (const t of Object.values(tokens)) {
-      if (t.aliasOf || !t.originalValue || t.$type !== 'transition') {
-        continue;
-      }
-
-      validateTransition(t.originalValue.$value, {
-        node: getObjMember(t.source.node, '$value') as momoa.ObjectNode,
-        filename: t.source.filename,
-      });
-    }
-
-    // Note: we validate sub-properties using other checks like valid-dimension, valid-font-family, etc.
-    // The only thing remaining is to check that all properties exist (since missing properties won’t appear as invalid)
-    function validateTransition(value: unknown, { node, filename }: { node: momoa.ObjectNode; filename?: string }) {
-      if (
-        !value ||
-        typeof value !== 'object' ||
-        !TRANSITION_REQUIRED_PROPERTIES.every((property) => property in value)
-      ) {
-        report({ messageId: ERROR, node, filename });
-      } else {
-        for (const key of Object.keys(value)) {
-          if (!TRANSITION_REQUIRED_PROPERTIES.includes(key as (typeof TRANSITION_REQUIRED_PROPERTIES)[number])) {
-            report({
-              messageId: ERROR_INVALID_PROP,
-              data: { key: JSON.stringify(key) },
-              node: getObjMember(node, key),
-              filename,
-            });
-          }
-        }
-      }
-    }
-  },
-};
-
-export default rule;

package/src/lint/plugin-core/rules/valid-typography.ts

@@ -1,67 +0,0 @@
-import type * as momoa from '@humanwhocodes/momoa';
-import { getObjMember } from '@terrazzo/json-schema-tools';
-import wcmatch from 'wildcard-match';
-import type { LintRule } from '../../../types.js';
-import { docsLink } from '../lib/docs.js';
-
-export const VALID_TYPOGRAPHY = 'core/valid-typography';
-
-const ERROR = 'ERROR';
-const ERROR_MISSING = 'ERROR_MISSING';
-
-export interface RuleRequiredTypographyPropertiesOptions {
-  /** Required typography properties */
-  requiredProperties: string[];
-  /** Token globs to ignore */
-  ignore?: string[];
-}
-
-const rule: LintRule<typeof ERROR | typeof ERROR_MISSING, RuleRequiredTypographyPropertiesOptions> = {
-  meta: {
-    messages: {
-      [ERROR]: `Expected object, received {{ value }}.`,
-      [ERROR_MISSING]: `Missing required property "{{ property }}".`,
-    },
-    docs: {
-      description: 'Require typography tokens to follow the format.',
-      url: docsLink(VALID_TYPOGRAPHY),
-    },
-  },
-  defaultOptions: {
-    requiredProperties: ['fontFamily', 'fontSize', 'fontWeight', 'letterSpacing', 'lineHeight'],
-  },
-  create({ tokens, options, report }) {
-    const isIgnored = options.ignore ? wcmatch(options.ignore) : () => false;
-    for (const t of Object.values(tokens)) {
-      if (t.aliasOf || !t.originalValue || t.$type !== 'typography' || isIgnored(t.id)) {
-        continue;
-      }
-
-      validateTypography(t.originalValue.$value, {
-        node: getObjMember(t.source.node, '$value') as momoa.ObjectNode,
-        filename: t.source.filename,
-      });
-
-      // Note: we validate sub-properties using other checks like valid-dimension, valid-font-family, etc.
-      // The only thing remaining is to check that all properties exist (since missing properties won’t appear as invalid)
-      function validateTypography(value: unknown, { node, filename }: { node: momoa.ObjectNode; filename?: string }) {
-        if (value && typeof value === 'object') {
-          for (const property of options.requiredProperties) {
-            if (!(property in value)) {
-              report({ messageId: ERROR_MISSING, data: { property }, node, filename });
-            }
-          }
-        } else {
-          report({
-            messageId: ERROR,
-            data: { value: JSON.stringify(value) },
-            node,
-            filename,
-          });
-        }
-      }
-    }
-  },
-};
-
-export default rule;

package/src/logger.ts

@@ -1,213 +0,0 @@
-import * as momoa from '@humanwhocodes/momoa';
-import pc from 'picocolors';
-import wcmatch from 'wildcard-match';
-import { codeFrameColumns } from './lib/code-frame.js';
-
-export const LOG_ORDER = ['error', 'warn', 'info', 'debug'] as const;
-export type LogSeverity = 'error' | 'warn' | 'info' | 'debug';
-export type LogLevel = LogSeverity | 'silent';
-export type LogGroup = 'config' | 'parser' | 'lint' | 'plugin' | 'server';
-
-export interface LogEntry {
-  /** Originator of log message */
-  group: LogGroup;
-  /** Error message to be logged */
-  message: string;
-  /** Prefix message with label */
-  label?: string;
-  /** File in disk */
-  filename?: URL;
-  /**
-   * Continue on error?
-   * @default false
-   */
-  continueOnError?: boolean;
-  /** Show a code frame for the erring node */
-  node?: momoa.AnyNode;
-  /** To show a code frame, provide the original source code */
-  src?: string;
-  /** Display performance timing */
-  timing?: number;
-}
-
-export interface DebugEntry {
-  group: LogGroup;
-  /** Error message to be logged */
-  message: string;
-  /** Current subtask or submodule */
-  label?: string;
-  /** Show code below message */
-  codeFrame?: { src: string; line: number; column: number };
-  /** Display performance timing */
-  timing?: number;
-}
-
-const MESSAGE_COLOR: Record<string, typeof pc.red | undefined> = { error: pc.red, warn: pc.yellow };
-
-const timeFormatter = new Intl.DateTimeFormat('en-us', {
-  hour: 'numeric',
-  hour12: false,
-  minute: 'numeric',
-  second: 'numeric',
-  fractionalSecondDigits: 3,
-});
-
-/**
- * @param {Entry} entry
- * @param {Severity} severity
- * @return {string}
- */
-export function formatMessage(entry: LogEntry, severity: LogSeverity) {
-  let message = entry.message;
-  message = `[${entry.group}${entry.label ? `:${entry.label}` : ''}] ${message}`;
-  if (severity in MESSAGE_COLOR) {
-    message = MESSAGE_COLOR[severity]!(message);
-  }
-  if (typeof entry.timing === 'number') {
-    message = `${message} ${formatTiming(entry.timing)}`;
-  }
-  if (entry.node) {
-    const start = entry.node?.loc?.start ?? { line: 0, column: 0 };
-    //  strip "file://" protocol, but not href
-    const loc = entry.filename
-      ? `${entry.filename?.href.replace(/^file:\/\//, '')}:${start?.line ?? 0}:${start?.column ?? 0}\n\n`
-      : '';
-    const codeFrame = codeFrameColumns(
-      entry.src ?? momoa.print(entry.node, { indent: 2 }),
-      { start },
-      { highlightCode: false },
-    );
-    message = `${message}\n\n${loc}${codeFrame}`;
-  }
-  return message;
-}
-
-export default class Logger {
-  level = 'info' as LogLevel;
-  debugScope = '*';
-  errorCount = 0;
-  warnCount = 0;
-  infoCount = 0;
-  debugCount = 0;
-
-  constructor(options?: { level?: LogLevel; debugScope?: string }) {
-    if (options?.level) {
-      this.level = options.level;
-    }
-    if (options?.debugScope) {
-      this.debugScope = options.debugScope;
-    }
-  }
-
-  setLevel(level: LogLevel) {
-    this.level = level;
-  }
-
-  /** Log an error message (always; can’t be silenced) */
-  error(...entries: LogEntry[]) {
-    const message: string[] = [];
-    let firstNode: momoa.AnyNode | undefined;
-    for (const entry of entries) {
-      this.errorCount++;
-      message.push(formatMessage(entry, 'error'));
-      if (entry.node) {
-        firstNode = entry.node;
-      }
-    }
-    if (entries.every((e) => e.continueOnError)) {
-      // biome-ignore lint/suspicious/noConsole: this is a logger
-      console.error(message.join('\n\n'));
-    } else {
-      const e = firstNode ? new TokensJSONError(message.join('\n\n')) : new Error(message.join('\n\n'));
-      throw e;
-    }
-  }
-
-  /** Log an info message (if logging level permits) */
-  info(...entries: LogEntry[]) {
-    for (const entry of entries) {
-      this.infoCount++;
-      if (this.level === 'silent' || LOG_ORDER.indexOf(this.level) < LOG_ORDER.indexOf('info')) {
-        return;
-      }
-      const message = formatMessage(entry, 'info');
-      // biome-ignore lint/suspicious/noConsole: this is a logger
-      console.log(message);
-    }
-  }
-
-  /** Log a warning message (if logging level permits) */
-  warn(...entries: LogEntry[]) {
-    for (const entry of entries) {
-      this.warnCount++;
-      if (this.level === 'silent' || LOG_ORDER.indexOf(this.level) < LOG_ORDER.indexOf('warn')) {
-        return;
-      }
-      const message = formatMessage(entry, 'warn');
-
-      // biome-ignore lint/suspicious/noConsole: this is a logger
-      console.warn(message);
-    }
-  }
-
-  /** Log a diagnostics message (if logging level permits) */
-  debug(...entries: DebugEntry[]) {
-    for (const entry of entries) {
-      if (this.level === 'silent' || LOG_ORDER.indexOf(this.level) < LOG_ORDER.indexOf('debug')) {
-        return;
-      }
-      this.debugCount++;
-
-      let message = formatMessage(entry, 'debug');
-
-      const debugPrefix = entry.label ? `${entry.group}:${entry.label}` : entry.group;
-      if (this.debugScope !== '*' && !wcmatch(this.debugScope)(debugPrefix)) {
-        return;
-      }
-
-      // debug color
-      message
-        .replace(/\[config[^\]]+\]/, (match) => pc.green(match))
-        .replace(/\[parser[^\]]+\]/, (match) => pc.magenta(match))
-        .replace(/\[lint[^\]]+\]/, (match) => pc.yellow(match))
-        .replace(/\[plugin[^\]]+\]/, (match) => pc.cyan(match));
-
-      message = `${pc.dim(timeFormatter.format(performance.now()))} ${message}`;
-      if (typeof entry.timing === 'number') {
-        message = `${message} ${formatTiming(entry.timing)}`;
-      }
-
-      // biome-ignore lint/suspicious/noConsole: this is a logger
-      console.log(message);
-    }
-  }
-
-  /** Get stats for current logger instance */
-  stats() {
-    return {
-      errorCount: this.errorCount,
-      warnCount: this.warnCount,
-      infoCount: this.infoCount,
-      debugCount: this.debugCount,
-    };
-  }
-}
-
-function formatTiming(timing: number): string {
-  let output = '';
-  if (timing < 1_000) {
-    output = `${Math.round(timing * 100) / 100}ms`;
-  } else if (timing < 60_000) {
-    output = `${Math.round(timing) / 1_000}s`;
-  } else {
-    output = `${Math.round(timing / 1_000) / 60}m`;
-  }
-  return pc.dim(`[${output}]`);
-}
-
-export class TokensJSONError extends Error {
-  constructor(message: string) {
-    super(message);
-    this.name = 'TokensJSONError';
-  }
-}

package/src/parse/index.ts

@@ -1,124 +0,0 @@
-import type fsType from 'node:fs/promises';
-import type { InputSource, InputSourceWithDocument } from '@terrazzo/json-schema-tools';
-import { pluralize, type TokenNormalizedSet } from '@terrazzo/token-tools';
-import lintRunner from '../lint/index.js';
-import Logger from '../logger.js';
-import { createSyntheticResolver } from '../resolver/create-synthetic-resolver.js';
-import { loadResolver } from '../resolver/load.js';
-import type { ConfigInit, ParseOptions, Resolver } from '../types.js';
-import { loadSources } from './load.js';
-
-export interface ParseResult {
-  tokens: TokenNormalizedSet;
-  sources: InputSourceWithDocument[];
-  resolver: Resolver;
-}
-
-/** Parse */
-export default async function parse(
-  _input: InputSource | InputSource[],
-  {
-    logger = new Logger(),
-    req = defaultReq,
-    skipLint = false,
-    config = {} as ConfigInit,
-    continueOnError = false,
-    yamlToMomoa,
-    transform,
-  }: ParseOptions = {} as ParseOptions,
-): Promise<ParseResult> {
-  const inputs = Array.isArray(_input) ? _input : [_input];
-  let tokens: TokenNormalizedSet = {};
-  let resolver: Resolver | undefined;
-  let sources: InputSourceWithDocument[] = [];
-
-  const totalStart = performance.now();
-
-  // 1. Load tokens
-  const initStart = performance.now();
-  const resolverResult = await loadResolver(inputs, { config, logger, req, yamlToMomoa });
-  // 1a. Resolver
-  if (resolverResult.resolver) {
-    tokens = resolverResult.tokens;
-    sources = resolverResult.sources;
-    resolver = resolverResult.resolver;
-  } else {
-    // 1b. No resolver
-    const tokenResult = await loadSources(inputs, {
-      req,
-      logger,
-      config,
-      continueOnError,
-      yamlToMomoa,
-      transform,
-    });
-    tokens = tokenResult.tokens;
-    sources = tokenResult.sources;
-  }
-  logger.debug({
-    message: 'Loaded tokens',
-    group: 'parser',
-    label: 'core',
-    timing: performance.now() - initStart,
-  });
-
-  if (skipLint !== true && config?.plugins?.length) {
-    const lintStart = performance.now();
-    await lintRunner({ tokens, sources, config, logger });
-    logger.debug({
-      message: 'Lint finished',
-      group: 'plugin',
-      label: 'lint',
-      timing: performance.now() - lintStart,
-    });
-  }
-
-  const resolverTiming = performance.now();
-  const finalResolver = resolver || (await createSyntheticResolver(tokens, { config, logger, req, sources }));
-  logger.debug({
-    message: 'Resolver finalized',
-    group: 'parser',
-    label: 'core',
-    timing: performance.now() - resolverTiming,
-  });
-
-  logger.debug({
-    message: 'Finish all parser tasks',
-    group: 'parser',
-    label: 'core',
-    timing: performance.now() - totalStart,
-  });
-
-  if (continueOnError) {
-    const { errorCount } = logger.stats();
-    if (errorCount > 0) {
-      logger.error({
-        group: 'parser',
-        message: `Parser encountered ${errorCount} ${pluralize(errorCount, 'error', 'errors')}. Exiting.`,
-      });
-    }
-  }
-
-  return {
-    tokens,
-    sources,
-    resolver: finalResolver,
-  };
-}
-
-let fs: typeof fsType | undefined;
-
-/** Fallback req */
-async function defaultReq(src: URL, _origin: URL) {
-  if (src.protocol === 'file:') {
-    if (!fs) {
-      fs = await import('node:fs/promises');
-    }
-    return await fs.readFile(src, 'utf8');
-  }
-  const res = await fetch(src);
-  if (!res.ok) {
-    throw new Error(`${src} responded with ${res.status}\n${await res.text()}`);
-  }
-  return await res.text();
-}