@verbatra/sdk 0.6.4 → 0.7.0

package/dist/index.js

@@ -4,7 +4,7 @@ import { existsSync } from 'fs';
 import { cosmiconfig } from 'cosmiconfig';
 import { TypeScriptLoader } from 'cosmiconfig-typescript-loader';
 import { randomUUID } from 'crypto';
-import { rm, access, mkdir, open, writeFile, rename } from 'fs/promises';
+import { mkdir, rm, access, open, writeFile, rename } from 'fs/promises';
 import Anthropic from '@anthropic-ai/sdk';
 import * as deepl from 'deepl-node';
 import { createRequire } from 'module';
@@ -258,6 +258,9 @@ var defaultFs = {
   createExclusive: (path, data) => createExclusive(path, data),
   deleteFile: async (path) => {
     await rm(path, { force: true });
+  },
+  mkdir: async (path) => {
+    await mkdir(path, { recursive: true });
   }
 };
 var MAX_GLOSSARY_FILE_BYTES = 1024 * 1024;
@@ -496,9 +499,109 @@ function assessValueDegeneracy(sourceValue, candidateValue) {
   }
   return { degenerate: hasRunawayRepetition(candidate) };
 }
+
+// src/locale-path/pattern.ts
 var LOCALE_TOKEN = "{locale}";
-function localeFilePath(cwd, pattern, locale) {
-  return resolve(cwd, pattern.replaceAll(LOCALE_TOKEN, locale));
+var SEPARATOR = /[/\\]/;
+function tokenOccupiesWholeSegments(pattern) {
+  return pattern.split(SEPARATOR).every((segment) => segment === LOCALE_TOKEN || !segment.includes(LOCALE_TOKEN));
+}
+function expandPattern(pattern, spelling) {
+  return pattern.replaceAll(LOCALE_TOKEN, () => spelling);
+}
+
+// src/locale-path/tag.ts
+var LANGUAGE = /^[a-z]{2,3}$/;
+var SCRIPT = /^[a-z]{4}$/;
+var REGION = /^([a-z]{2}|[0-9]{3})$/;
+var NUMERIC_REGION = /^[0-9]{3}$/;
+var VARIANT = /^([a-z0-9]{5,8}|[0-9][a-z0-9]{3})$/;
+function subtagIf(subtags, index, pattern) {
+  const subtag = subtags[index];
+  return subtag !== void 0 && pattern.test(subtag) ? subtag : void 0;
+}
+function parseLocaleTag(locale) {
+  const subtags = locale.toLowerCase().split("-");
+  const language = subtags[0];
+  if (language === void 0 || !LANGUAGE.test(language)) {
+    return void 0;
+  }
+  let index = 1;
+  const script = subtagIf(subtags, index, SCRIPT);
+  index += script === void 0 ? 0 : 1;
+  const region = subtagIf(subtags, index, REGION);
+  index += region === void 0 ? 0 : 1;
+  const variants = subtags.slice(index);
+  if (!variants.every((variant) => VARIANT.test(variant))) {
+    return void 0;
+  }
+  return { language, script, region, variants };
+}
+function conventionalSubtags(tag) {
+  const subtags = [tag.language];
+  if (tag.script !== void 0) {
+    subtags.push(tag.script.charAt(0).toUpperCase() + tag.script.slice(1));
+  }
+  if (tag.region !== void 0) {
+    subtags.push(tag.region.toUpperCase());
+  }
+  subtags.push(...tag.variants);
+  return subtags;
+}
+
+// src/locale-path/android.ts
+var SOURCE_SEGMENT = "values";
+var MAX_BCP47_SUBTAGS = 4;
+var UI_MODE_LANGUAGE_COLLISION = "car";
+function needsBcp47(tag, subtagCount) {
+  return tag.script !== void 0 || tag.variants.length > 0 || tag.region !== void 0 && NUMERIC_REGION.test(tag.region) || tag.language === UI_MODE_LANGUAGE_COLLISION || subtagCount >= 3;
+}
+function legacySegment(tag) {
+  return tag.region === void 0 ? `${SOURCE_SEGMENT}-${tag.language}` : `${SOURCE_SEGMENT}-${tag.language}-r${tag.region.toUpperCase()}`;
+}
+function androidSegment(locale, isSourceLocale) {
+  if (isSourceLocale) {
+    return SOURCE_SEGMENT;
+  }
+  const tag = parseLocaleTag(locale);
+  if (tag === void 0) {
+    return void 0;
+  }
+  const subtags = conventionalSubtags(tag);
+  if (!needsBcp47(tag, subtags.length)) {
+    return legacySegment(tag);
+  }
+  if (subtags.length > MAX_BCP47_SUBTAGS) {
+    return void 0;
+  }
+  return `${SOURCE_SEGMENT}-b+${subtags.join("+")}`;
+}
+
+// src/locale-path/style.ts
+var LOCALE_STYLES = ["literal", "posix", "android"];
+var SEGMENT_STYLES = /* @__PURE__ */ new Set(["android"]);
+var UNSAFE_IN_SEGMENT = /[/\\\0]/;
+function isSegmentStyle(style) {
+  return SEGMENT_STYLES.has(style);
+}
+function posixSpelling(locale) {
+  const tag = parseLocaleTag(locale);
+  if (tag === void 0 || tag.script !== void 0 || tag.variants.length > 0) {
+    return void 0;
+  }
+  if (tag.region !== void 0 && NUMERIC_REGION.test(tag.region)) {
+    return void 0;
+  }
+  return locale.replaceAll("-", "_");
+}
+function spellLocale(locale, style, isSourceLocale) {
+  if (style === "android") {
+    return androidSegment(locale, isSourceLocale);
+  }
+  return style === "posix" ? posixSpelling(locale) : locale;
+}
+function isSafeSpelling(spelling) {
+  return spelling.length > 0 && !UNSAFE_IN_SEGMENT.test(spelling) && spelling !== "." && spelling !== "..";
 }
 function checkBatchIntegrity(inputs, extract, compare) {
   const integrity = /* @__PURE__ */ new Map();
@@ -671,7 +774,7 @@ function deriveJsonSchema(schema) {
       result[key] = value;
     }
   }
-  return result;
+  return { ...result, type: "object" };
 }
 function partitionTranslations(translations, requested) {
   const firstSeen = /* @__PURE__ */ new Map();
@@ -791,6 +894,8 @@ function assertNotTruncated(truncated) {
 var RATE_LIMITED_STATUS = 429;
 var TIMEOUT_STATUS = 408;
 var AUTH_FAILED_STATUSES = /* @__PURE__ */ new Set([401, 403]);
+var SERVER_OUTAGE_MIN_STATUS = 500;
+var SERVER_OUTAGE_MAX_STATUS = 599;
 var RATE_LIMITED_CLASS_NAMES = /* @__PURE__ */ new Set([
   "RateLimitError",
   "TooManyRequestsError"
@@ -812,6 +917,9 @@ function getErrorStatus(error) {
   const status = error.status;
   return typeof status === "number" ? status : void 0;
 }
+function isServerOutageStatus(status) {
+  return status !== void 0 && status >= SERVER_OUTAGE_MIN_STATUS && status <= SERVER_OUTAGE_MAX_STATUS;
+}
 function readClassName(error) {
   if (typeof error !== "object" || error === null) {
     return void 0;
@@ -829,6 +937,9 @@ function classifyProviderError(error) {
   if (status === TIMEOUT_STATUS) {
     return "TIMEOUT";
   }
+  if (isServerOutageStatus(status)) {
+    return "PROVIDER_UNAVAILABLE";
+  }
   const className = readClassName(error);
   if (className !== void 0) {
     if (RATE_LIMITED_CLASS_NAMES.has(className)) {
@@ -860,10 +971,12 @@ var PROVIDER_CALL_FAILED_MESSAGE = "The translation provider request failed.";
 var RATE_LIMITED_MESSAGE = "The translation provider rate-limited this request.";
 var TIMEOUT_MESSAGE = "The translation provider request timed out.";
 var AUTH_FAILED_MESSAGE = "The translation provider rejected the request credentials.";
+var PROVIDER_UNAVAILABLE_MESSAGE = "The translation provider is currently unavailable.";
 var MESSAGE_BY_CODE = {
   RATE_LIMITED: RATE_LIMITED_MESSAGE,
   TIMEOUT: TIMEOUT_MESSAGE,
   AUTH_FAILED: AUTH_FAILED_MESSAGE,
+  PROVIDER_UNAVAILABLE: PROVIDER_UNAVAILABLE_MESSAGE,
   PROVIDER_ERROR: PROVIDER_CALL_FAILED_MESSAGE
 };
 async function guardProviderCall(call, signal) {
@@ -944,14 +1057,14 @@ function resolveOpenAiCompatibleKey(customEnvVar) {
   }
   return OPENAI_COMPATIBLE_KEY_PLACEHOLDER;
 }
+function toMutableRequest(request) {
+  return request;
+}
 function createDefaultClient() {
   const sdk = new Anthropic({ apiKey: requireAnthropicKey(), logLevel: "off" });
   return {
     messages: {
-      create: async (body, options) => await sdk.messages.create(
-        body,
-        options
-      )
+      create: async (body, options) => await sdk.messages.create(toMutableRequest(body), options)
     }
   };
 }
@@ -1369,7 +1482,7 @@ function createDefaultClient3() {
     models: {
       generateContent: (request) => withGeminiRetry(
         async () => await ai.models.generateContent(
-          request
+          toMutableRequest(request)
         ),
         request.config.abortSignal
       )
@@ -1533,7 +1646,7 @@ function createDefaultClient4() {
     chat: {
       completions: {
         create: async (body, options) => await sdk.chat.completions.create(
-          body,
+          toMutableRequest(body),
           options
         )
       }
@@ -1734,7 +1847,7 @@ function createDefaultClient5(config) {
     chat: {
       completions: {
         create: async (body, options) => await sdk.chat.completions.create(
-          body,
+          toMutableRequest(body),
           options
         )
       }
@@ -1816,7 +1929,13 @@ var verbatraConfigSchema = z.strictObject({
   targetLocales: z.array(z.string().min(1)).min(1),
   format: supportedFormatSchema,
   files: z.strictObject({
-    pattern: z.string().min(1)
+    pattern: z.string().min(1),
+    /**
+     * How the `{locale}` token in `pattern` is spelled for each locale. Absent means `"literal"`,
+     * the configured tag verbatim, which is what every layout except Android and the POSIX
+     * underscore layouts needs. See `LocaleStyle` for what each style produces.
+     */
+    localeStyle: z.enum(LOCALE_STYLES).optional()
   }),
   provider: providerConfigSchema,
   /**
@@ -1837,8 +1956,9 @@ var verbatraConfigSchema = z.strictObject({
    * Opt-in plural-category generation, off by default. When true, and only for an i18next-JSON project
    * translated by an LLM provider, verbatra synthesizes the CLDR plural forms a target language
    * requires but the source does not supply (for example Polish few/many). The per-run
-   * `generatePlurals` option on `translate` overrides this. Unsupported cases (DeepL, non-i18next, an
-   * unknown language) fall back to the per-locale plural warning.
+   * `generatePlurals` option on `translate` overrides this. A plural form the target file already holds
+   * is adopted, never generated over. Unsupported cases (DeepL, non-i18next, an unknown language) fall
+   * back to the per-locale plural warning.
    */
   generatePlurals: z.boolean().optional(),
   /**
@@ -1973,6 +2093,63 @@ async function loadConfig(options = {}) {
   const { config } = await loadConfigWithMeta(options);
   return config;
 }
+var DEFAULT_LOCALE_STYLE = "literal";
+function validatePattern(pattern, style) {
+  if (!pattern.includes(LOCALE_TOKEN)) {
+    throw new SdkError(
+      "LOCALE_LAYOUT_INVALID",
+      `The files pattern "${pattern}" must contain the ${LOCALE_TOKEN} token.`
+    );
+  }
+  if (isSegmentStyle(style) && !tokenOccupiesWholeSegments(pattern)) {
+    throw new SdkError(
+      "LOCALE_LAYOUT_INVALID",
+      `The "${style}" locale style expands ${LOCALE_TOKEN} to a whole path segment, so the token must stand alone between separators, but the pattern "${pattern}" embeds it in a segment.`
+    );
+  }
+}
+function safeSpelling(locale, style, sourceLocale) {
+  const spelling = spellLocale(locale, style, locale === sourceLocale);
+  if (spelling === void 0) {
+    throw new SdkError(
+      "LOCALE_LAYOUT_INVALID",
+      `The "${style}" locale style has no valid path spelling for the locale "${locale}".`
+    );
+  }
+  if (!isSafeSpelling(spelling)) {
+    throw new SdkError(
+      "LOCALE_LAYOUT_INVALID",
+      `The locale "${locale}" expands to "${spelling}" under the "${style}" locale style, which is not a single path segment.`
+    );
+  }
+  return spelling;
+}
+function buildForwardMap(config, pathFor) {
+  const forward = /* @__PURE__ */ new Map();
+  for (const locale of [config.sourceLocale, ...config.targetLocales]) {
+    const path = pathFor(locale);
+    const claimed = forward.get(path);
+    if (claimed !== void 0 && claimed !== locale) {
+      throw new SdkError(
+        "LOCALE_PATH_COLLISION",
+        `The locales "${claimed}" and "${locale}" both resolve to ${path}.`
+      );
+    }
+    forward.set(path, locale);
+  }
+  return forward;
+}
+function createLocalePathResolver(cwd, config) {
+  const style = config.files.localeStyle ?? DEFAULT_LOCALE_STYLE;
+  const pattern = config.files.pattern;
+  validatePattern(pattern, style);
+  const pathFor = (locale) => resolve(cwd, expandPattern(pattern, safeSpelling(locale, style, config.sourceLocale)));
+  const forward = buildForwardMap(config, pathFor);
+  return {
+    pathFor,
+    localeFor: (absolutePath) => forward.get(resolve(cwd, absolutePath))
+  };
+}
 var LOCAL_DIR_NAME = ".verbatra-local";
 var LOCK_FILE_GUARD_STEM = "_lockfile";
 var DEFAULT_POLL_INTERVAL_MS = 100;
@@ -3994,7 +4171,7 @@ function selectAdapter(format, registry = createDefaultRegistry()) {
 
 // src/flow/read-target.ts
 async function readTargetResource(input) {
-  const path = localeFilePath(input.cwd, input.filesPattern, input.locale);
+  const path = input.resolver.pathFor(input.locale);
   if (!await input.fs.fileExists(path)) {
     return { locale: input.locale, namespace: "", format: input.format, entries: /* @__PURE__ */ new Map() };
   }
@@ -4021,7 +4198,7 @@ function selectLocales(config, requested) {
 
 // src/flow/source.ts
 async function readSource(config, cwd, fs, adapter) {
-  const sourcePath = localeFilePath(cwd, config.files.pattern, config.sourceLocale);
+  const sourcePath = createLocalePathResolver(cwd, config).pathFor(config.sourceLocale);
   if (!await fs.fileExists(sourcePath)) {
     throw new SdkError(
       "SOURCE_UNREADABLE",
@@ -4042,8 +4219,7 @@ async function readSource(config, cwd, fs, adapter) {
 // src/flow/diff-locales.ts
 async function readTarget(cwd, config, adapter, fs, locale) {
   return readTargetResource({
-    cwd,
-    filesPattern: config.files.pattern,
+    resolver: createLocalePathResolver(cwd, config),
     format: config.format,
     locale,
     adapter,
@@ -4164,7 +4340,7 @@ async function editEntry(input, deps = {}) {
     }
     const merged = new Map(target.entries);
     merged.set(input.key, { ...sourceEntry, value: input.value, namespace: target.namespace });
-    const path = localeFilePath(cwd, config.files.pattern, locale);
+    const path = createLocalePathResolver(cwd, config).pathFor(locale);
     await adapter.write(
       { locale, namespace: target.namespace, format: config.format, entries: merged },
       path
@@ -4387,7 +4563,7 @@ async function retranslateEntry(input, deps = {}) {
     }
     const merged = new Map(target.entries);
     merged.set(input.key, { ...sourceEntry, value, namespace: target.namespace });
-    const path = localeFilePath(cwd, config.files.pattern, locale);
+    const path = createLocalePathResolver(cwd, config).pathFor(locale);
     await adapter.write(
       { locale, namespace: target.namespace, format: config.format, entries: merged },
       path
@@ -4806,6 +4982,9 @@ function syntheticEntry(item) {
     meaning: `CLDR plural category "${item.category}"`
   };
 }
+function isAdopted(item, targetKeys, baseline) {
+  return targetKeys.has(item.targetKey) && !baseline.has(item.targetKey);
+}
 function staleItems(items, baseline) {
   return items.filter((item) => {
     const hash = generatedLockHash(item.governingEntries, item.category);
@@ -4825,7 +5004,10 @@ function buildRequest2(context, entries) {
 }
 async function generatePluralForms(context) {
   const plan = planPluralGeneration(context.source, context.targetLocale, context.format);
-  const stale = staleItems(plan.items, context.baseline);
+  const candidates = plan.items.filter(
+    (item) => !isAdopted(item, context.targetKeys, context.baseline)
+  );
+  const stale = staleItems(candidates, context.baseline);
   if (stale.length === 0) {
     return EMPTY_RESULT;
   }
@@ -5015,8 +5197,7 @@ async function shouldWriteTarget(params, path, changed) {
 }
 async function runLocale(params) {
   const target = await readTargetResource({
-    cwd: params.cwd,
-    filesPattern: params.filesPattern,
+    resolver: params.resolver,
     format: params.format,
     locale: params.targetLocale,
     adapter: params.adapter,
@@ -5093,11 +5274,11 @@ async function runLocale(params) {
       merged.set(key, { ...hit.source, value: hit.value, namespace: target.namespace });
     }
   }
-  const generation = await runGeneration(params, provider);
+  const generation = await runGeneration(params, provider, new Set(target.entries.keys()));
   for (const form of generation.accepted) {
     merged.set(form.targetKey, { ...form.entry, namespace: target.namespace });
   }
-  const path = localeFilePath(params.cwd, params.filesPattern, params.targetLocale);
+  const path = params.resolver.pathFor(params.targetLocale);
   const writeNeeded = await shouldWriteTarget(params, path, {
     accepted: accepted.size,
     pruned: pruned.length,
@@ -5160,7 +5341,7 @@ var NO_GENERATION_RESULT = {
   usage: void 0,
   tripped: false
 };
-async function runGeneration(params, provider) {
+async function runGeneration(params, provider, targetKeys) {
   if (!params.generatePlurals || provider.kind !== "llm") {
     return NO_GENERATION_RESULT;
   }
@@ -5174,6 +5355,7 @@ async function runGeneration(params, provider) {
     glossary: params.glossary,
     tone: params.tone,
     baseline: params.baseline,
+    targetKeys,
     maxBatchSize: params.maxBatchSize,
     budget: params.budget
   });
@@ -5416,7 +5598,7 @@ function buildLocaleRunParams(context, targetLocale, baseline) {
     adapter: context.adapter,
     provider: context.provider,
     cwd: context.cwd,
-    filesPattern: context.config.files.pattern,
+    resolver: context.resolver,
     sourceLocale: context.config.sourceLocale,
     targetLocale,
     format: context.config.format,
@@ -5570,6 +5752,7 @@ async function translate2(input, deps = {}) {
     config.maxTokens,
     config.budgetBehavior ?? DEFAULT_BUDGET_BEHAVIOR
   );
+  const resolver = createLocalePathResolver(cwd, config);
   const adapter = selectAdapter(config.format, deps.adapterRegistry);
   const provider = dryRun ? void 0 : selectProvider(config.provider, deps.createProvider);
   const source = await readSource(config, cwd, fs, adapter);
@@ -5580,6 +5763,7 @@ async function translate2(input, deps = {}) {
     provider,
     cwd,
     config,
+    resolver,
     prune,
     generatePlurals,
     maxBatchSize,
@@ -5620,6 +5804,123 @@ var ExchangeError = class extends Error {
     this.code = code;
   }
 };
+var DELIMITER = {
+  csv: ",",
+  tsv: "	"
+};
+var FORBIDDEN_FILE_NAME_CHARS = /[\\/:*?"<>|\p{Cc}]/u;
+function assertPlainFileLocale(locale) {
+  if (locale.length === 0 || locale === "." || locale === "..") {
+    throw new ExchangeError(
+      "WORKBOOK_INVALID",
+      `The locale "${locale}" cannot be an interchange file name: it must name a file, not a directory.`
+    );
+  }
+  if (FORBIDDEN_FILE_NAME_CHARS.test(locale)) {
+    throw new ExchangeError(
+      "WORKBOOK_INVALID",
+      `The locale "${locale}" cannot be an interchange file name: it must not contain a path separator, a control character, or any of : * ? " < > | .`
+    );
+  }
+}
+function delimitedFileName(locale, format) {
+  assertPlainFileLocale(locale);
+  return `${locale}.${format}`;
+}
+var COLUMN = {
+  key: 1,
+  source: 2,
+  current: 3,
+  status: 4,
+  translation: 5,
+  sourceHash: 6,
+  context: 7,
+  reviewStatus: 8,
+  reviewReasons: 9
+};
+var HEADERS = [
+  "Key",
+  "Source",
+  "Current translation",
+  "Status",
+  "Translation",
+  "Source hash",
+  "Context",
+  "Review status",
+  "Review reasons"
+];
+var HEADER_ROW = 1;
+var INSTRUCTIONS_SHEET_NAME = "Instructions";
+var rowSchema = z.object({
+  key: z.string().min(1),
+  source: z.string(),
+  currentTarget: z.string(),
+  status: z.enum(["new", "changed", "unchanged"]),
+  sourceHash: z.string(),
+  translation: z.string(),
+  context: z.string(),
+  reviewStatus: z.enum(["ok", "review"]).catch("ok"),
+  reviewReasons: z.string().catch("")
+});
+var MALFORMED_ROW_COLUMN = "Status";
+function cellAt(cells, column) {
+  return cells[column - 1] ?? "";
+}
+function parseRowCells(cells) {
+  const result = rowSchema.safeParse({
+    key: cellAt(cells, COLUMN.key),
+    source: cellAt(cells, COLUMN.source),
+    currentTarget: cellAt(cells, COLUMN.current),
+    status: cellAt(cells, COLUMN.status),
+    sourceHash: cellAt(cells, COLUMN.sourceHash),
+    translation: cellAt(cells, COLUMN.translation).trim(),
+    context: cellAt(cells, COLUMN.context),
+    reviewStatus: cellAt(cells, COLUMN.reviewStatus),
+    reviewReasons: cellAt(cells, COLUMN.reviewReasons)
+  });
+  if (!result.success) {
+    return { ok: false, column: MALFORMED_ROW_COLUMN };
+  }
+  return { ok: true, row: result.data };
+}
+function rowCells(row) {
+  const cells = new Array(HEADERS.length).fill("");
+  cells[COLUMN.key - 1] = row.key;
+  cells[COLUMN.source - 1] = row.source;
+  cells[COLUMN.current - 1] = row.currentTarget;
+  cells[COLUMN.status - 1] = row.status;
+  cells[COLUMN.translation - 1] = row.translation;
+  cells[COLUMN.sourceHash - 1] = row.sourceHash;
+  cells[COLUMN.context - 1] = row.context;
+  cells[COLUMN.reviewStatus - 1] = row.reviewStatus;
+  cells[COLUMN.reviewReasons - 1] = row.reviewReasons;
+  return cells;
+}
+var QUOTE = '"';
+var ESCAPED_QUOTE = '""';
+var LINE_BREAK = "\n";
+var UTF8_BOM = "\uFEFF";
+function needsQuoting(value, delimiter) {
+  return value.includes(delimiter) || value.includes(QUOTE) || value.includes("\n") || value.includes("\r") || value !== value.trim();
+}
+function encodeField(value, delimiter) {
+  if (!needsQuoting(value, delimiter)) {
+    return value;
+  }
+  return `${QUOTE}${value.replaceAll(QUOTE, ESCAPED_QUOTE)}${QUOTE}`;
+}
+function encodeRecord(fields, delimiter) {
+  return fields.map((field) => encodeField(field, delimiter)).join(delimiter);
+}
+function buildDelimited(sheet, format) {
+  const delimiter = DELIMITER[format];
+  const records = [encodeRecord(HEADERS, delimiter)];
+  for (const row of sheet.rows) {
+    records.push(encodeRecord(rowCells(row), delimiter));
+  }
+  const text = `${records.join(LINE_BREAK)}${LINE_BREAK}`;
+  return format === "csv" ? `${UTF8_BOM}${text}` : text;
+}
 var INSTRUCTIONS_LINES = [
   "How to use this workbook",
   "",
@@ -5648,30 +5949,6 @@ var INSTRUCTIONS_LINES = [
   "a value with a broken placeholder, invalid ICU, or a source that changed since export is",
   "withheld (not written) and reported so you can fix and resubmit it."
 ];
-var COLUMN = {
-  key: 1,
-  source: 2,
-  current: 3,
-  status: 4,
-  translation: 5,
-  sourceHash: 6,
-  context: 7,
-  reviewStatus: 8,
-  reviewReasons: 9
-};
-var HEADERS = [
-  "Key",
-  "Source",
-  "Current translation",
-  "Status",
-  "Translation",
-  "Source hash",
-  "Context",
-  "Review status",
-  "Review reasons"
-];
-var HEADER_ROW = 1;
-var INSTRUCTIONS_SHEET_NAME = "Instructions";
 var READ_ONLY_FILL = {
   type: "pattern",
   pattern: "solid",
@@ -5831,6 +6108,12 @@ async function buildWorkbook(model) {
   const protectedBytes = await protectWorkbookStructure(serialized);
   return Uint8Array.prototype.slice.call(protectedBytes);
 }
+var DEFAULT_DELIMITED_LIMITS = {
+  maxInputBytes: 32 * 1024 * 1024,
+  maxRowsPerFile: 1e5,
+  maxFieldsPerRow: 64,
+  maxFieldLength: 1024 * 1024
+};
 var DEFAULT_WORKBOOK_LIMITS = {
   maxDecompressedBytes: 64 * 1024 * 1024,
   maxEntryCount: 1024,
@@ -5838,6 +6121,205 @@ var DEFAULT_WORKBOOK_LIMITS = {
   maxRowsPerSheet: 1e5,
   maxCellsPerRow: 64
 };
+var QUOTE2 = '"';
+var HEADER_RECORD = 1;
+function scanQuotedField(text, start) {
+  const parts = [];
+  let cursor = start;
+  for (; ; ) {
+    const quote = text.indexOf(QUOTE2, cursor);
+    if (quote === -1) {
+      parts.push(text.slice(cursor));
+      return { value: parts.join(""), next: text.length };
+    }
+    parts.push(text.slice(cursor, quote));
+    if (text[quote + 1] !== QUOTE2) {
+      return { value: parts.join(""), next: quote + 1 };
+    }
+    parts.push(QUOTE2);
+    cursor = quote + 2;
+  }
+}
+function scanPlainField(text, start, delimiter) {
+  let cursor = start;
+  while (cursor < text.length) {
+    const char = text[cursor];
+    if (char === delimiter || char === "\n" || char === "\r") {
+      break;
+    }
+    cursor += 1;
+  }
+  return { value: text.slice(start, cursor), next: cursor };
+}
+function scanField(text, start, delimiter) {
+  if (text[start] !== QUOTE2) {
+    return scanPlainField(text, start, delimiter);
+  }
+  const quoted = scanQuotedField(text, start + 1);
+  const trailing = scanPlainField(text, quoted.next, delimiter);
+  return { value: `${quoted.value}${trailing.value}`, next: trailing.next };
+}
+function countLineBreaks(value) {
+  let breaks = 0;
+  for (let index = 0; index < value.length; index += 1) {
+    const char = value[index];
+    if (char === "\n") {
+      breaks += 1;
+    } else if (char === "\r") {
+      breaks += 1;
+      if (value[index + 1] === "\n") {
+        index += 1;
+      }
+    }
+  }
+  return breaks;
+}
+function scanRecord(text, start, delimiter, limits) {
+  const fields = [];
+  let breaks = 0;
+  let cursor = start;
+  for (; ; ) {
+    const field = scanField(text, cursor, delimiter);
+    assertFieldLength(field.value, limits);
+    fields.push(field.value);
+    breaks += countLineBreaks(field.value);
+    assertFieldCount(fields.length, limits);
+    cursor = field.next;
+    if (text[cursor] !== delimiter) {
+      return { fields, breaks, next: cursor };
+    }
+    cursor += 1;
+  }
+}
+function consumeLineBreak(text, cursor) {
+  if (text[cursor] === "\r") {
+    return text[cursor + 1] === "\n" ? cursor + 2 : cursor + 1;
+  }
+  return text[cursor] === "\n" ? cursor + 1 : cursor;
+}
+function scanRecords(text, delimiter, limits) {
+  const records = [];
+  let cursor = 0;
+  let line = 1;
+  while (cursor < text.length) {
+    const record = scanRecord(text, cursor, delimiter, limits);
+    records.push({ fields: record.fields, line });
+    assertRecordCount(records.length, limits);
+    const next = consumeLineBreak(text, record.next);
+    if (next === record.next) {
+      break;
+    }
+    line += record.breaks + 1;
+    cursor = next;
+  }
+  return records;
+}
+function assertInputBytes(text, limits) {
+  if (Buffer.byteLength(text, "utf8") > limits.maxInputBytes) {
+    throw new ExchangeError(
+      "WORKBOOK_INVALID",
+      `The interchange file is larger than the maximum of ${limits.maxInputBytes} bytes.`
+    );
+  }
+}
+function assertFieldLength(value, limits) {
+  if (value.length > limits.maxFieldLength) {
+    throw new ExchangeError(
+      "WORKBOOK_INVALID",
+      `The interchange file has a field longer than the maximum of ${limits.maxFieldLength} characters.`
+    );
+  }
+}
+function assertFieldCount(count, limits) {
+  if (count > limits.maxFieldsPerRow) {
+    throw new ExchangeError(
+      "WORKBOOK_INVALID",
+      `The interchange file has a row with more than the maximum of ${limits.maxFieldsPerRow} fields.`
+    );
+  }
+}
+function assertRecordCount(count, limits) {
+  if (count - HEADER_RECORD > limits.maxRowsPerFile) {
+    throw new ExchangeError(
+      "WORKBOOK_INVALID",
+      `The interchange file has more than the maximum of ${limits.maxRowsPerFile} rows.`
+    );
+  }
+}
+function assertHeaderRecord(records) {
+  const header = records[0]?.fields;
+  if (header === void 0 || header.length !== HEADERS.length) {
+    throw new ExchangeError(
+      "WORKBOOK_INVALID",
+      `The interchange file does not start with the expected header line of ${HEADERS.length} columns.`
+    );
+  }
+  for (const [index, label] of HEADERS.entries()) {
+    if (header[index] !== label) {
+      throw new ExchangeError(
+        "WORKBOOK_INVALID",
+        `The interchange file's header line does not match the expected columns (column ${index + 1} should be "${label}").`
+      );
+    }
+  }
+}
+function fieldCountColumn(fieldCount) {
+  const label = HEADERS.at(Math.min(fieldCount, HEADERS.length - 1));
+  if (label === void 0) {
+    return MALFORMED_ROW_COLUMN;
+  }
+  return label;
+}
+function isBlankRecord(fields) {
+  return fields.length === 1 && fields[0] === "";
+}
+function readRecord(fields, locale, at, into) {
+  const { row, line } = at;
+  if (isBlankRecord(fields)) {
+    return;
+  }
+  if (fields.length !== HEADERS.length) {
+    into.malformed.push({ locale, row, line, column: fieldCountColumn(fields.length) });
+    return;
+  }
+  if (fields[COLUMN.key - 1] === "") {
+    return;
+  }
+  const outcome = parseRowCells(fields);
+  if (!outcome.ok) {
+    into.malformed.push({ locale, row, line, column: outcome.column });
+    return;
+  }
+  if (into.seenKeys.has(outcome.row.key)) {
+    into.duplicates.push({ locale, key: outcome.row.key, row, line });
+    return;
+  }
+  into.seenKeys.add(outcome.row.key);
+  into.rows.push(outcome.row);
+}
+function readDelimited(input, options = {}) {
+  const limits = options.limits ?? DEFAULT_DELIMITED_LIMITS;
+  assertInputBytes(input.text, limits);
+  const text = input.text.startsWith(UTF8_BOM) ? input.text.slice(UTF8_BOM.length) : input.text;
+  const records = scanRecords(text, DELIMITER[input.format], limits);
+  assertHeaderRecord(records);
+  const into = {
+    rows: [],
+    malformed: [],
+    duplicates: [],
+    seenKeys: /* @__PURE__ */ new Set()
+  };
+  for (const [index, record] of records.entries()) {
+    if (index >= HEADER_RECORD) {
+      readRecord(record.fields, input.locale, { row: index + 1, line: record.line }, into);
+    }
+  }
+  return {
+    sheets: [{ locale: input.locale, rows: into.rows }],
+    malformedRows: into.malformed,
+    duplicateKeys: into.duplicates
+  };
+}
 function assertNoDoctype2(name, xml) {
   if (/<!DOCTYPE/i.test(xml) || /<!ENTITY/i.test(xml)) {
     throw new ExchangeError(
@@ -5914,17 +6396,6 @@ async function guardWorkbookBytes(bytes, limits) {
     assertNoDoctype2(file.name, content);
   }
 }
-var rowSchema = z.object({
-  key: z.string().min(1),
-  source: z.string(),
-  currentTarget: z.string(),
-  status: z.enum(["new", "changed", "unchanged"]),
-  sourceHash: z.string(),
-  translation: z.string(),
-  context: z.string(),
-  reviewStatus: z.enum(["ok", "review"]).catch("ok"),
-  reviewReasons: z.string().catch("")
-});
 function cellString(cell) {
   const value = cell.value;
   if (value === null || value === void 0) {
@@ -5949,24 +6420,8 @@ function assertHeader(sheet) {
     );
   }
 }
-var MALFORMED_ROW_COLUMN = "Status";
 function parseRow(row) {
-  const candidate = {
-    key: cellString(row.getCell(COLUMN.key)),
-    source: cellString(row.getCell(COLUMN.source)),
-    currentTarget: cellString(row.getCell(COLUMN.current)),
-    status: cellString(row.getCell(COLUMN.status)),
-    sourceHash: cellString(row.getCell(COLUMN.sourceHash)),
-    translation: cellString(row.getCell(COLUMN.translation)).trim(),
-    context: cellString(row.getCell(COLUMN.context)),
-    reviewStatus: cellString(row.getCell(COLUMN.reviewStatus)),
-    reviewReasons: cellString(row.getCell(COLUMN.reviewReasons))
-  };
-  const result = rowSchema.safeParse(candidate);
-  if (!result.success) {
-    return { ok: false, column: MALFORMED_ROW_COLUMN };
-  }
-  return { ok: true, row: result.data };
+  return parseRowCells(HEADERS.map((_, index) => cellString(row.getCell(index + 1))));
 }
 function readDataSheet(sheet, limits) {
   assertHeader(sheet);
@@ -6040,8 +6495,52 @@ async function readWorkbook(bytes, options = {}) {
   return { sheets, malformedRows, duplicateKeys };
 }
 
+// src/flow/workbook/exchange-format.ts
+function isDelimitedFormat(format) {
+  return format === "csv" || format === "tsv";
+}
+var MANIFEST_VERSION = 1;
+var MAX_MANIFEST_BYTES = 1024 * 1024;
+function exportManifestFileName(format) {
+  return `.verbatra-export-${format}.json`;
+}
+var manifestSchema = z.object({
+  version: z.number().int().positive(),
+  format: z.enum(["csv", "tsv"]),
+  locales: z.array(z.string())
+});
+async function writeExportManifest(fs, directory, format, locales) {
+  const manifest = { version: MANIFEST_VERSION, format, locales: [...locales] };
+  await fs.writeFile(
+    join(directory, exportManifestFileName(format)),
+    `${JSON.stringify(manifest, null, 2)}
+`
+  );
+}
+async function readExportedLocales(fs, directory, format) {
+  const read = await fs.readFileBounded(
+    join(directory, exportManifestFileName(format)),
+    MAX_MANIFEST_BYTES
+  );
+  if (read.kind !== "ok") {
+    return void 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(read.content);
+  } catch {
+    return void 0;
+  }
+  const result = manifestSchema.safeParse(parsed);
+  if (!result.success || result.data.version !== MANIFEST_VERSION || result.data.format !== format) {
+    return void 0;
+  }
+  return new Set(result.data.locales);
+}
+
 // src/flow/workbook/export-workbook.ts
 var DEFAULT_WORKBOOK_PATH = "verbatra-translations.xlsx";
+var DEFAULT_DELIMITED_PATH = "verbatra-translations";
 function reasonLabel(reason) {
   return reason.toLowerCase().replace(/_/g, "-");
 }
@@ -6105,6 +6604,21 @@ function buildRows(source, target, baseline, includeUnchanged, adapter, glossary
   }
   return [...rows].sort((a, b) => a.key < b.key ? -1 : 1);
 }
+async function writeDelimitedFiles(fs, directory, format, sheets) {
+  await fs.mkdir?.(directory);
+  for (const sheet of sheets) {
+    await fs.writeFile(
+      join(directory, delimitedFileName(sheet.locale, format)),
+      buildDelimited(sheet, format)
+    );
+  }
+  await writeExportManifest(
+    fs,
+    directory,
+    format,
+    sheets.map((sheet) => sheet.locale)
+  );
+}
 async function exportWorkbook(input, deps = {}) {
   const config = input.config;
   const cwd = input.cwd ?? process.cwd();
@@ -6127,10 +6641,17 @@ async function exportWorkbook(input, deps = {}) {
       return { locale, rows };
     })
   );
-  const model = { sheets };
-  const bytes = await buildWorkbook(model);
-  const path = resolve(cwd, input.out ?? DEFAULT_WORKBOOK_PATH);
-  await fs.writeBytes(path, bytes);
+  const format = input.format ?? "xlsx";
+  const path = resolve(
+    cwd,
+    input.out ?? (isDelimitedFormat(format) ? DEFAULT_DELIMITED_PATH : DEFAULT_WORKBOOK_PATH)
+  );
+  if (isDelimitedFormat(format)) {
+    await writeDelimitedFiles(fs, path, format, sheets);
+  } else {
+    const model = { sheets };
+    await fs.writeBytes(path, await buildWorkbook(model));
+  }
   return {
     path,
     locales: sheets.map((sheet) => ({ locale: sheet.locale, rows: sheet.rows.length }))
@@ -6259,6 +6780,7 @@ function importLocale(params) {
 
 // src/flow/workbook/import-workbook.ts
 var MAX_WORKBOOK_FILE_BYTES = 64 * 1024 * 1024;
+var MAX_DELIMITED_FILE_BYTES = 32 * 1024 * 1024;
 async function readWorkbookBytes(path, fs) {
   const read = await fs.readBytesBounded(path, MAX_WORKBOOK_FILE_BYTES);
   if (read.kind === "missing") {
@@ -6272,6 +6794,75 @@ async function readWorkbookBytes(path, fs) {
   }
   return read.bytes;
 }
+async function readDelimitedText(path, fs) {
+  const read = await fs.readFileBounded(path, MAX_DELIMITED_FILE_BYTES);
+  if (read.kind === "missing") {
+    return void 0;
+  }
+  if (read.kind === "too-large") {
+    throw new SdkError(
+      "SOURCE_INVALID",
+      `The interchange file at ${path} exceeds the maximum allowed size of ${MAX_DELIMITED_FILE_BYTES} bytes.`
+    );
+  }
+  return read.content;
+}
+async function collectDelimitedSources(path, config, fs, format) {
+  const single = await readDelimitedText(path, fs);
+  if (single !== void 0) {
+    return { sources: [{ locale: basename(path, `.${format}`), text: single }], staleLocales: [] };
+  }
+  const exported = await readExportedLocales(fs, path, format);
+  const sources = [];
+  const staleLocales = [];
+  for (const locale of config.targetLocales) {
+    const text = await readDelimitedText(join(path, delimitedFileName(locale, format)), fs);
+    if (text === void 0) {
+      continue;
+    }
+    if (exported !== void 0 && !exported.has(locale)) {
+      staleLocales.push(locale);
+      continue;
+    }
+    sources.push({ locale, text });
+  }
+  if (sources.length === 0 && staleLocales.length === 0) {
+    throw new SdkError(
+      "SOURCE_UNREADABLE",
+      `No ${format} file was found at ${path}, and it holds no <locale>.${format} file for any configured target locale.`
+    );
+  }
+  return { sources, staleLocales };
+}
+function parseDelimitedSources(sources, format) {
+  const sheets = [];
+  const malformedRows = [];
+  const duplicateKeys = [];
+  for (const source of sources) {
+    const data = readDelimited({ text: source.text, locale: source.locale, format });
+    sheets.push(...data.sheets);
+    malformedRows.push(...data.malformedRows);
+    duplicateKeys.push(...data.duplicateKeys);
+  }
+  return { sheets, malformedRows, duplicateKeys };
+}
+async function readImportData(path, config, fs, format) {
+  try {
+    if (isDelimitedFormat(format)) {
+      const handoff = await collectDelimitedSources(path, config, fs, format);
+      return {
+        data: parseDelimitedSources(handoff.sources, format),
+        staleLocales: handoff.staleLocales
+      };
+    }
+    return { data: await readWorkbook(await readWorkbookBytes(path, fs)), staleLocales: [] };
+  } catch (error) {
+    if (error instanceof SdkError) {
+      throw error;
+    }
+    throw new SdkError("SOURCE_INVALID", errorMessage(error));
+  }
+}
 function mergeAccepted(target, accepted) {
   const merged = new Map(target.entries);
   for (const [key, { value, source }] of accepted) {
@@ -6312,18 +6903,43 @@ function computeLockEntries2(source, merged, baseline, accepted) {
 }
 var MissingSheetError = class extends Error {
   code = "WORKBOOK_SHEET_MISSING";
-  constructor(locale) {
+  constructor(locale, format) {
     super(
-      `The workbook has no sheet (tab) for the configured target locale "${locale}". The tab may have been renamed, deleted, or reordered out of the workbook.`
+      isDelimitedFormat(format) ? `The handoff has no "${delimitedFileName(locale, format)}" file for the configured target locale "${locale}". The file may have been renamed, deleted, or left out of the directory.` : `The workbook has no sheet (tab) for the configured target locale "${locale}". The tab may have been renamed, deleted, or reordered out of the workbook.`
     );
     this.name = "MissingSheetError";
   }
 };
+var StaleHandoffFileError = class extends Error {
+  code = "HANDOFF_FILE_STALE";
+  constructor(locale, format) {
+    super(
+      `The file "${delimitedFileName(locale, format)}" is left over from an earlier export that included the target locale "${locale}"; the most recent export into this directory did not. Its rows were not applied, because they reflect that earlier run. Re-export the locale to refresh the file, or delete it.`
+    );
+    this.name = "StaleHandoffFileError";
+  }
+};
+function absentLocaleFailures(config, sheets, format, staleLocales) {
+  const present = new Set(sheets.map((sheet) => sheet.locale));
+  const stale = new Set(staleLocales);
+  const failures = [];
+  for (const locale of config.targetLocales) {
+    if (present.has(locale)) {
+      continue;
+    }
+    const error = stale.has(locale) && isDelimitedFormat(format) ? new StaleHandoffFileError(locale, format) : new MissingSheetError(locale, format);
+    failures.push(failureSummary(locale, error));
+  }
+  return failures;
+}
+function lineOf(reported) {
+  return reported.line === void 0 ? {} : { line: reported.line };
+}
 async function runSheet(ctx, sheet, lock) {
   if (!ctx.config.targetLocales.includes(sheet.locale)) {
     throw new SdkError(
       "CONFIG_INVALID",
-      `The workbook has a sheet named "${sheet.locale}", which is not a configured target locale. It may be a renamed, added, or reordered tab; leave every language tab named exactly as exported.`
+      isDelimitedFormat(ctx.format) ? `The handoff has a file named "${sheet.locale}.${ctx.format}", whose locale is not a configured target locale. Name every interchange file exactly as it was exported.` : `The workbook has a sheet named "${sheet.locale}", which is not a configured target locale. It may be a renamed, added, or reordered tab; leave every language tab named exactly as exported.`
     );
   }
   const target = await readTarget(ctx.cwd, ctx.config, ctx.adapter, ctx.fs, sheet.locale);
@@ -6335,15 +6951,15 @@ async function runSheet(ctx, sheet, lock) {
     baseline,
     adapter: ctx.adapter,
     sourceInvalidIcuKeys: ctx.sourceInvalidIcuKeys,
-    malformedRows: ctx.malformedRows.filter((problem) => problem.locale === sheet.locale).map((problem) => ({ row: problem.row, column: problem.column })),
-    duplicateKeys: ctx.duplicateKeys.filter((duplicate) => duplicate.locale === sheet.locale).map((duplicate) => ({ key: duplicate.key, row: duplicate.row }))
+    malformedRows: ctx.malformedRows.filter((problem) => problem.locale === sheet.locale).map((problem) => ({ row: problem.row, column: problem.column, ...lineOf(problem) })),
+    duplicateKeys: ctx.duplicateKeys.filter((duplicate) => duplicate.locale === sheet.locale).map((duplicate) => ({ key: duplicate.key, row: duplicate.row, ...lineOf(duplicate) }))
   });
   if (ctx.dryRun) {
     return { summary, lockEntries: {}, cacheAdditions: {} };
   }
   const merged = mergeAccepted(target, accepted);
   if (accepted.size > 0) {
-    const path = localeFilePath(ctx.cwd, ctx.config.files.pattern, sheet.locale);
+    const path = createLocalePathResolver(ctx.cwd, ctx.config).pathFor(sheet.locale);
     await ctx.adapter.write(
       {
         locale: sheet.locale,
@@ -6367,14 +6983,13 @@ async function importWorkbook(input, deps = {}) {
   const fs = deps.fs ?? defaultFs;
   const adapter = selectAdapter(config.format, deps.adapterRegistry);
   const source = await readSource(config, cwd, fs, adapter);
-  const workbookPath = resolve(cwd, input.workbook);
-  const bytes = await readWorkbookBytes(workbookPath, fs);
-  let data;
-  try {
-    data = await readWorkbook(bytes);
-  } catch (error) {
-    throw new SdkError("SOURCE_INVALID", errorMessage(error));
-  }
+  const format = input.format ?? "xlsx";
+  const { data, staleLocales } = await readImportData(
+    resolve(cwd, input.workbook),
+    config,
+    fs,
+    format
+  );
   const lock = await readLockFile(lockFilePath(cwd), fs);
   const ctx = {
     config,
@@ -6385,7 +7000,8 @@ async function importWorkbook(input, deps = {}) {
     sourceInvalidIcuKeys: source.invalidIcuKeys,
     dryRun,
     malformedRows: data.malformedRows,
-    duplicateKeys: data.duplicateKeys
+    duplicateKeys: data.duplicateKeys,
+    format
   };
   const summaries = [];
   const cacheAdditions = /* @__PURE__ */ new Map();
@@ -6410,12 +7026,7 @@ async function importWorkbook(input, deps = {}) {
       summaries.push(failureSummary(sheet.locale, error));
     }
   }
-  const presentLocales = new Set(data.sheets.map((sheet) => sheet.locale));
-  for (const locale of config.targetLocales) {
-    if (!presentLocales.has(locale)) {
-      summaries.push(failureSummary(locale, new MissingSheetError(locale)));
-    }
-  }
+  summaries.push(...absentLocaleFailures(config, data.sheets, format, staleLocales));
   if (!dryRun) {
     await feedTranslationMemory(cwd, fs, computeFingerprint(config), cacheAdditions);
   }
@@ -6464,7 +7075,8 @@ async function watch(input, deps = {}) {
   const debounceMs = input.debounceMs ?? DEFAULT_DEBOUNCE_MS;
   const fs = deps.fs ?? defaultFs;
   resolveRunConcurrency(input.concurrency, false, input.config);
-  const sourcePath = localeFilePath(cwd, input.config.files.pattern, input.config.sourceLocale);
+  const resolver = createLocalePathResolver(cwd, input.config);
+  const sourcePath = resolver.pathFor(input.config.sourceLocale);
   if (!await fs.fileExists(sourcePath)) {
     throw new SdkError(
       "SOURCE_UNREADABLE",
@@ -6547,6 +7159,6 @@ async function watch(input, deps = {}) {
   return { stop };
 }
 
-export { CACHE_FILE_NAME, DEFAULT_WORKBOOK_PATH, LOCK_FILE_NAME, SdkError, check, defineConfig, diff, diffLocaleSnapshots, editEntry, exportWorkbook, importWorkbook, keyIntegrity, keyValue, loadConfig, loadConfigWithMeta, loadLockFile, lockState, readLocaleFileSnapshot, retranslateEntry, runStatus, scaffoldingMetadata, translate2 as translate, verbatraConfigSchema, watch };
+export { CACHE_FILE_NAME, DEFAULT_DELIMITED_PATH, DEFAULT_WORKBOOK_PATH, LOCK_FILE_NAME, SdkError, check, createLocalePathResolver, defineConfig, diff, diffLocaleSnapshots, editEntry, exportWorkbook, importWorkbook, keyIntegrity, keyValue, loadConfig, loadConfigWithMeta, loadLockFile, lockState, readLocaleFileSnapshot, retranslateEntry, runStatus, scaffoldingMetadata, translate2 as translate, verbatraConfigSchema, watch };
 //# sourceMappingURL=index.js.map
 //# sourceMappingURL=index.js.map