wrangler
Version:
Command-line interface for all things Cloudflare Workers
1,688 lines (1,679 loc) • 10.9 MB
JavaScript
'use strict';
var fs25 = require('fs');
var path5 = require('path');
var Url = require('url');
var process8 = require('process');
var assert40 = require('assert');
var util2 = require('util');
var os8 = require('os');
var tty = require('tty');
var childProcess = require('child_process');
var crypto = require('crypto');
var esbuild = require('esbuild');
var fs12 = require('fs/promises');
var miniflare = require('miniflare');
var async_hooks = require('async_hooks');
var console$1 = require('console');
var S = require('readline');
var Stream = require('stream');
var http = require('http');
var https = require('https');
var zlib = require('zlib');
var web = require('stream/web');
var events = require('events');
var module2 = require('module');
var buffer = require('buffer');
var promises = require('timers/promises');
var domain = require('domain');
var consumers = require('stream/consumers');
var string_decoder = require('string_decoder');
var blake3Wasm = require('blake3-wasm');
var workerd = require('workerd');
var net = require('net');
function _interopDefault (e) { return e && e.__esModule ? e : { default: e }; }
function _interopNamespace(e) {
if (e && e.__esModule) return e;
var n = Object.create(null);
if (e) {
Object.keys(e).forEach(function (k) {
if (k !== 'default') {
var d = Object.getOwnPropertyDescriptor(e, k);
Object.defineProperty(n, k, d.get ? d : {
enumerable: true,
get: function () { return e[k]; }
});
}
});
}
n.default = e;
return Object.freeze(n);
}
var fs25__namespace = /*#__PURE__*/_interopNamespace(fs25);
var path5__namespace = /*#__PURE__*/_interopNamespace(path5);
var Url__default = /*#__PURE__*/_interopDefault(Url);
var process8__default = /*#__PURE__*/_interopDefault(process8);
var assert40__default = /*#__PURE__*/_interopDefault(assert40);
var util2__namespace = /*#__PURE__*/_interopNamespace(util2);
var os8__namespace = /*#__PURE__*/_interopNamespace(os8);
var tty__default = /*#__PURE__*/_interopDefault(tty);
var childProcess__default = /*#__PURE__*/_interopDefault(childProcess);
var crypto__default = /*#__PURE__*/_interopDefault(crypto);
var esbuild__namespace = /*#__PURE__*/_interopNamespace(esbuild);
var fs12__default = /*#__PURE__*/_interopDefault(fs12);
var async_hooks__namespace = /*#__PURE__*/_interopNamespace(async_hooks);
var S__default = /*#__PURE__*/_interopDefault(S);
var Stream__namespace = /*#__PURE__*/_interopNamespace(Stream);
var http__namespace = /*#__PURE__*/_interopNamespace(http);
var https__namespace = /*#__PURE__*/_interopNamespace(https);
var zlib__namespace = /*#__PURE__*/_interopNamespace(zlib);
var events__default = /*#__PURE__*/_interopDefault(events);
var module2__default = /*#__PURE__*/_interopDefault(module2);
var domain__namespace = /*#__PURE__*/_interopNamespace(domain);
var net__default = /*#__PURE__*/_interopDefault(net);
var __create = Object.create;
var __defProp = Object.defineProperty;
var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
var __getOwnPropNames = Object.getOwnPropertyNames;
var __getProtoOf = Object.getPrototypeOf;
var __hasOwnProp = Object.prototype.hasOwnProperty;
var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
var __require = /* @__PURE__ */ ((x7) => typeof require !== "undefined" ? require : typeof Proxy !== "undefined" ? new Proxy(x7, {
get: (a6, b7) => (typeof require !== "undefined" ? require : a6)[b7]
}) : x7)(function(x7) {
if (typeof require !== "undefined") return require.apply(this, arguments);
throw Error('Dynamic require of "' + x7 + '" is not supported');
});
var __esm = (fn2, res) => function __init() {
return fn2 && (res = (0, fn2[__getOwnPropNames(fn2)[0]])(fn2 = 0)), res;
};
var __commonJS = (cb2, mod) => function __require2() {
return mod || (0, cb2[__getOwnPropNames(cb2)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
};
var __export = (target, all2) => {
for (var name2 in all2)
__defProp(target, name2, { get: all2[name2], enumerable: true });
};
var __copyProps = (to, from, except, desc) => {
if (from && typeof from === "object" || typeof from === "function") {
for (let key of __getOwnPropNames(from))
if (!__hasOwnProp.call(to, key) && key !== except)
__defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
}
return to;
};
var __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget);
var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
// If the importer is in node compatibility mode or this is not an ESM
// file that has been converted to a CommonJS file using a Babel-
// compatible transform (i.e. "__esModule" has not been set), then set
// "default" to the CommonJS "module.exports" for node compatibility.
isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
mod
));
var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
// import_meta_url.js
var import_meta_url;
var init_import_meta_url = __esm({
"import_meta_url.js"() {
import_meta_url = __require("url").pathToFileURL(__filename);
}
});
// ../../node_modules/.pnpm/cloudflare@5.2.0_encoding@0.1.13/node_modules/cloudflare/_shims/registry.mjs
function setShims(shims, options = { auto: false }) {
if (auto) {
throw new Error(`you must \`import 'cloudflare/shims/${shims.kind}'\` before importing anything else from cloudflare`);
}
if (kind) {
throw new Error(`can't \`import 'cloudflare/shims/${shims.kind}'\` after \`import 'cloudflare/shims/${kind}'\``);
}
auto = options.auto;
kind = shims.kind;
fetch2 = shims.fetch;
shims.Request;
shims.Response;
shims.Headers;
FormData2 = shims.FormData;
shims.Blob;
File2 = shims.File;
shims.ReadableStream;
getMultipartRequestOptions = shims.getMultipartRequestOptions;
getDefaultAgent = shims.getDefaultAgent;
fileFromPath = shims.fileFromPath;
isFsReadStream = shims.isFsReadStream;
}
var auto, kind, fetch2, FormData2, File2, getMultipartRequestOptions, getDefaultAgent, fileFromPath, isFsReadStream;
var init_registry = __esm({
"../../node_modules/.pnpm/cloudflare@5.2.0_encoding@0.1.13/node_modules/cloudflare/_shims/registry.mjs"() {
init_import_meta_url();
auto = false;
kind = void 0;
fetch2 = void 0;
FormData2 = void 0;
File2 = void 0;
getMultipartRequestOptions = void 0;
getDefaultAgent = void 0;
fileFromPath = void 0;
isFsReadStream = void 0;
__name(setShims, "setShims");
}
});
// ../../node_modules/.pnpm/cloudflare@5.2.0_encoding@0.1.13/node_modules/cloudflare/_shims/MultipartBody.mjs
var MultipartBody;
var init_MultipartBody = __esm({
"../../node_modules/.pnpm/cloudflare@5.2.0_encoding@0.1.13/node_modules/cloudflare/_shims/MultipartBody.mjs"() {
init_import_meta_url();
MultipartBody = class {
static {
__name(this, "MultipartBody");
}
constructor(body) {
this.body = body;
}
get [Symbol.toStringTag]() {
return "MultipartBody";
}
};
}
});
// ../workers-utils/dist/chunk-PSOC3TD3.mjs
function formatCompatibilityDate(date) {
return date.toISOString().slice(0, 10);
}
function assertNever(_value) {
}
function createFatalError(message, isJson, code, telemetryMessage) {
if (isJson) {
return new JsonFriendlyFatalError(
JSON.stringify(message),
code,
telemetryMessage
);
} else {
return new FatalError(`${message}`, code, telemetryMessage);
}
}
function mapWorkerMetadataBindings(bindings) {
return bindings.filter((binding) => binding.type !== "secret_text").reduce((configObj, binding) => {
switch (binding.type) {
case "plain_text":
{
configObj.vars = {
...configObj.vars ?? {},
[binding.name]: binding.text
};
}
break;
case "json":
{
configObj.vars = {
...configObj.vars ?? {},
name: binding.name,
json: binding.json
};
}
break;
case "kv_namespace":
{
configObj.kv_namespaces = [
...configObj.kv_namespaces ?? [],
{ id: binding.namespace_id, binding: binding.name }
];
}
break;
case "durable_object_namespace":
{
configObj.durable_objects = {
bindings: [
...configObj.durable_objects?.bindings ?? [],
{
name: binding.name,
class_name: binding.class_name,
script_name: binding.script_name,
environment: binding.environment
}
]
};
}
break;
case "d1":
{
configObj.d1_databases = [
...configObj.d1_databases ?? [],
{
binding: binding.name,
database_id: binding.id
}
];
}
break;
case "browser":
{
configObj.browser = {
binding: binding.name
};
}
break;
case "ai":
{
configObj.ai = {
binding: binding.name
};
}
break;
case "images":
{
configObj.images = {
binding: binding.name
};
}
break;
case "media":
{
configObj.media = {
binding: binding.name
};
}
break;
case "r2_bucket":
{
configObj.r2_buckets = [
...configObj.r2_buckets ?? [],
{
binding: binding.name,
bucket_name: binding.bucket_name,
jurisdiction: binding.jurisdiction
}
];
}
break;
case "secrets_store_secret":
{
configObj.secrets_store_secrets = [
...configObj.secrets_store_secrets ?? [],
{
binding: binding.name,
store_id: binding.store_id,
secret_name: binding.secret_name
}
];
}
break;
case "unsafe_hello_world": {
configObj.unsafe_hello_world = [
...configObj.unsafe_hello_world ?? [],
{
binding: binding.name,
enable_timer: binding.enable_timer
}
];
break;
}
case "service":
{
configObj.services = [
...configObj.services ?? [],
{
binding: binding.name,
service: binding.service,
environment: binding.environment,
entrypoint: binding.entrypoint
}
];
}
break;
case "analytics_engine":
{
configObj.analytics_engine_datasets = [
...configObj.analytics_engine_datasets ?? [],
{ binding: binding.name, dataset: binding.dataset }
];
}
break;
case "dispatch_namespace":
{
configObj.dispatch_namespaces = [
...configObj.dispatch_namespaces ?? [],
{
binding: binding.name,
namespace: binding.namespace,
...binding.outbound && {
outbound: {
service: binding.outbound.worker.service,
environment: binding.outbound.worker.environment,
parameters: binding.outbound.params?.map((p7) => p7.name) ?? []
}
}
}
];
}
break;
case "logfwdr":
{
configObj.logfwdr = {
bindings: [
...configObj.logfwdr?.bindings ?? [],
{ name: binding.name, destination: binding.destination }
]
};
}
break;
case "wasm_module":
{
configObj.wasm_modules = {
...configObj.wasm_modules ?? {},
[binding.name]: binding.part
};
}
break;
case "text_blob":
{
configObj.text_blobs = {
...configObj.text_blobs ?? {},
[binding.name]: binding.part
};
}
break;
case "data_blob":
{
configObj.data_blobs = {
...configObj.data_blobs ?? {},
[binding.name]: binding.part
};
}
break;
case "secret_text":
break;
case "version_metadata": {
{
configObj.version_metadata = {
binding: binding.name
};
}
break;
}
case "send_email": {
configObj.send_email = [
...configObj.send_email ?? [],
{
name: binding.name,
destination_address: binding.destination_address,
allowed_destination_addresses: binding.allowed_destination_addresses,
allowed_sender_addresses: binding.allowed_sender_addresses
}
];
break;
}
case "queue":
configObj.queues ??= { producers: [] };
configObj.queues.producers = [
...configObj.queues.producers ?? [],
{
binding: binding.name,
queue: binding.queue_name,
delivery_delay: binding.delivery_delay
}
];
break;
case "vectorize":
configObj.vectorize = [
...configObj.vectorize ?? [],
{
binding: binding.name,
index_name: binding.index_name
}
];
break;
case "hyperdrive":
configObj.hyperdrive = [
...configObj.hyperdrive ?? [],
{
binding: binding.name,
id: binding.id
}
];
break;
case "mtls_certificate":
configObj.mtls_certificates = [
...configObj.mtls_certificates ?? [],
{
binding: binding.name,
certificate_id: binding.certificate_id
}
];
break;
case "pipelines":
configObj.pipelines = [
...configObj.pipelines ?? [],
{
binding: binding.name,
pipeline: binding.pipeline
}
];
break;
case "assets":
throw new FatalError(
"`wrangler init --from-dash` is not yet supported for Workers with Assets"
);
case "inherit":
configObj.unsafe = {
bindings: [...configObj.unsafe?.bindings ?? [], binding],
metadata: configObj.unsafe?.metadata ?? void 0
};
break;
case "workflow":
{
configObj.workflows = [
...configObj.workflows ?? [],
{
binding: binding.name,
name: binding.workflow_name,
class_name: binding.class_name,
script_name: binding.script_name
}
];
}
break;
case "worker_loader":
{
configObj.worker_loaders = [
...configObj.worker_loaders ?? [],
{
binding: binding.name
}
];
}
break;
case "ratelimit":
{
configObj.ratelimits = [
...configObj.ratelimits ?? [],
{
name: binding.name,
namespace_id: binding.namespace_id,
simple: {
limit: binding.simple.limit,
period: binding.simple.period
}
}
];
}
break;
case "vpc_service":
{
configObj.vpc_services = [
...configObj.vpc_services ?? [],
{
binding: binding.name,
service_id: binding.service_id
}
];
}
break;
default: {
configObj.unsafe = {
bindings: [...configObj.unsafe?.bindings ?? [], binding],
metadata: configObj.unsafe?.metadata ?? void 0
};
}
}
return configObj;
}, {});
}
function convertWorkerToWranglerConfig(config) {
const mappedBindings = mapWorkerMetadataBindings(config.bindings);
const durableObjectClassNames = config.bindings.filter(
(binding) => binding.type === "durable_object_namespace" && binding.script_name === config.name
).map(
(durableObject) => durableObject.class_name
);
const allRoutes = [
...config.routes.map((r8) => ({
pattern: r8.pattern,
zone_name: r8.zone_name
})),
...config.domains.map((c7) => ({
pattern: c7.hostname,
zone_name: c7.zone_name,
custom_domain: true
}))
];
return {
name: config.name,
main: config.entrypoint,
workers_dev: config.subdomain.enabled,
preview_urls: config.subdomain.previews_enabled,
compatibility_date: config.compatibility_date ?? formatCompatibilityDate(/* @__PURE__ */ new Date()),
compatibility_flags: config.compatibility_flags,
...allRoutes.length ? { routes: allRoutes } : {},
placement: config.placement?.mode === "smart" ? { mode: "smart" } : void 0,
limits: config.limits,
...durableObjectClassNames.length && config.migration_tag ? {
migrations: [
{
tag: config.migration_tag,
new_classes: durableObjectClassNames
}
]
} : {},
...config.schedules.length ? {
triggers: {
crons: config.schedules.map((scheduled) => scheduled.cron)
}
} : {},
tail_consumers: config.tail_consumers ?? void 0,
observability: config.observability,
...mappedBindings
};
}
function constructWranglerConfig(workerOrWorkers) {
let workers;
if (Array.isArray(workerOrWorkers)) {
workers = workerOrWorkers;
} else {
workers = [workerOrWorkers];
}
const topLevelEnv = workers.find(
(w7) => !w7.tags?.some((t8) => t8.startsWith(ENVIRONMENT_TAG_PREFIX))
);
const workerName = topLevelEnv?.name ?? workers[0].name;
const entrypoint = topLevelEnv?.entrypoint ?? workers[0].entrypoint;
let combinedConfig;
if (topLevelEnv) {
combinedConfig = convertWorkerToWranglerConfig(topLevelEnv);
} else {
combinedConfig = {
name: workerName,
main: entrypoint
};
}
for (const env6 of workers) {
const serviceTag = env6.tags?.find(
(t8) => t8 === `${SERVICE_TAG_PREFIX}${workerName}`
);
const envTag = env6.tags?.find((t8) => t8.startsWith(ENVIRONMENT_TAG_PREFIX));
if (serviceTag !== `${SERVICE_TAG_PREFIX}${workerName}` || envTag === void 0) {
continue;
}
const [_5, envName] = envTag.split("=");
combinedConfig.env ??= {};
combinedConfig.env[envName] = convertWorkerToWranglerConfig(env6);
}
return combinedConfig;
}
var __defProp2, __name2, INHERIT_SYMBOL, SERVICE_TAG_PREFIX, ENVIRONMENT_TAG_PREFIX, PATH_TO_DEPLOY_CONFIG, UserError, FatalError, CommandLineArgsError, JsonFriendlyFatalError, MissingConfigError;
var init_chunk_PSOC3TD3 = __esm({
"../workers-utils/dist/chunk-PSOC3TD3.mjs"() {
init_import_meta_url();
__defProp2 = Object.defineProperty;
__name2 = /* @__PURE__ */ __name((target, value) => __defProp2(target, "name", { value, configurable: true }), "__name");
INHERIT_SYMBOL = Symbol.for("inherit_binding");
SERVICE_TAG_PREFIX = "cf:service=";
ENVIRONMENT_TAG_PREFIX = "cf:environment=";
PATH_TO_DEPLOY_CONFIG = ".wrangler/deploy/config.json";
__name(formatCompatibilityDate, "formatCompatibilityDate");
__name2(formatCompatibilityDate, "formatCompatibilityDate");
__name(assertNever, "assertNever");
__name2(assertNever, "assertNever");
UserError = class extends Error {
static {
__name(this, "UserError");
}
static {
__name2(this, "UserError");
}
telemetryMessage;
constructor(message, options) {
super(message, options);
Object.setPrototypeOf(this, new.target.prototype);
this.telemetryMessage = options?.telemetryMessage === true ? message : options?.telemetryMessage;
}
};
(class extends UserError {
static {
__name(this, "DeprecationError");
}
static {
__name2(this, "DeprecationError");
}
constructor(message, options) {
super(`Deprecation:
${message}`, options);
}
});
FatalError = class extends UserError {
static {
__name(this, "FatalError");
}
constructor(message, code, options) {
super(message, options);
this.code = code;
}
static {
__name2(this, "FatalError");
}
};
CommandLineArgsError = class extends UserError {
static {
__name(this, "CommandLineArgsError");
}
static {
__name2(this, "CommandLineArgsError");
}
};
JsonFriendlyFatalError = class extends FatalError {
static {
__name(this, "JsonFriendlyFatalError");
}
constructor(message, code, options) {
super(message, code, options);
this.code = code;
}
static {
__name2(this, "JsonFriendlyFatalError");
}
};
MissingConfigError = class extends Error {
static {
__name(this, "MissingConfigError");
}
static {
__name2(this, "MissingConfigError");
}
telemetryMessage;
constructor(key) {
super(`Missing config value for ${key}`);
this.telemetryMessage = `Missing config value for ${key}`;
}
};
__name(createFatalError, "createFatalError");
__name2(createFatalError, "createFatalError");
__name(mapWorkerMetadataBindings, "mapWorkerMetadataBindings");
__name2(mapWorkerMetadataBindings, "mapWorkerMetadataBindings");
__name(convertWorkerToWranglerConfig, "convertWorkerToWranglerConfig");
__name2(convertWorkerToWranglerConfig, "convertWorkerToWranglerConfig");
__name(constructWranglerConfig, "constructWranglerConfig");
__name2(constructWranglerConfig, "constructWranglerConfig");
}
});
function getLineColFromPtr(string, ptr) {
let lines = string.slice(0, ptr).split(/\r\n|\n|\r/g);
return [lines.length, lines.pop().length + 1];
}
function makeCodeBlock(string, line, column) {
let lines = string.split(/\r\n|\n|\r/g);
let codeblock = "";
let numberLen = (Math.log10(line + 1) | 0) + 1;
for (let i6 = line - 1; i6 <= line + 1; i6++) {
let l7 = lines[i6 - 1];
if (!l7)
continue;
codeblock += i6.toString().padEnd(numberLen, " ");
codeblock += ": ";
codeblock += l7;
codeblock += "\n";
if (i6 === line) {
codeblock += " ".repeat(numberLen + column + 2);
codeblock += "^\n";
}
}
return codeblock;
}
function isEscaped(str, ptr) {
let i6 = 0;
while (str[ptr - ++i6] === "\\")
;
return --i6 && i6 % 2;
}
function indexOfNewline(str, start = 0, end = str.length) {
let idx = str.indexOf("\n", start);
if (str[idx - 1] === "\r")
idx--;
return idx <= end ? idx : -1;
}
function skipComment(str, ptr) {
for (let i6 = ptr; i6 < str.length; i6++) {
let c7 = str[i6];
if (c7 === "\n")
return i6;
if (c7 === "\r" && str[i6 + 1] === "\n")
return i6 + 1;
if (c7 < " " && c7 !== " " || c7 === "\x7F") {
throw new TomlError2("control characters are not allowed in comments", {
toml: str,
ptr
});
}
}
return str.length;
}
function skipVoid(str, ptr, banNewLines, banComments) {
let c7;
while ((c7 = str[ptr]) === " " || c7 === " " || !banNewLines && (c7 === "\n" || c7 === "\r" && str[ptr + 1] === "\n"))
ptr++;
return banComments || c7 !== "#" ? ptr : skipVoid(str, skipComment(str, ptr), banNewLines);
}
function skipUntil(str, ptr, sep6, end, banNewLines = false) {
if (!end) {
ptr = indexOfNewline(str, ptr);
return ptr < 0 ? str.length : ptr;
}
for (let i6 = ptr; i6 < str.length; i6++) {
let c7 = str[i6];
if (c7 === "#") {
i6 = indexOfNewline(str, i6);
} else if (c7 === sep6) {
return i6 + 1;
} else if (c7 === end || banNewLines && (c7 === "\n" || c7 === "\r" && str[i6 + 1] === "\n")) {
return i6;
}
}
throw new TomlError2("cannot find end of structure", {
toml: str,
ptr
});
}
function getStringEnd(str, seek) {
let first = str[seek];
let target = first === str[seek + 1] && str[seek + 1] === str[seek + 2] ? str.slice(seek, seek + 3) : first;
seek += target.length - 1;
do
seek = str.indexOf(target, ++seek);
while (seek > -1 && first !== "'" && isEscaped(str, seek));
if (seek > -1) {
seek += target.length;
if (target.length > 1) {
if (str[seek] === first)
seek++;
if (str[seek] === first)
seek++;
}
}
return seek;
}
function parseString(str, ptr = 0, endPtr = str.length) {
let isLiteral = str[ptr] === "'";
let isMultiline = str[ptr++] === str[ptr] && str[ptr] === str[ptr + 1];
if (isMultiline) {
endPtr -= 2;
if (str[ptr += 2] === "\r")
ptr++;
if (str[ptr] === "\n")
ptr++;
}
let tmp = 0;
let isEscape;
let parsed = "";
let sliceStart = ptr;
while (ptr < endPtr - 1) {
let c7 = str[ptr++];
if (c7 === "\n" || c7 === "\r" && str[ptr] === "\n") {
if (!isMultiline) {
throw new TomlError2("newlines are not allowed in strings", {
toml: str,
ptr: ptr - 1
});
}
} else if (c7 < " " && c7 !== " " || c7 === "\x7F") {
throw new TomlError2("control characters are not allowed in strings", {
toml: str,
ptr: ptr - 1
});
}
if (isEscape) {
isEscape = false;
if (c7 === "u" || c7 === "U") {
let code = str.slice(ptr, ptr += c7 === "u" ? 4 : 8);
if (!ESCAPE_REGEX.test(code)) {
throw new TomlError2("invalid unicode escape", {
toml: str,
ptr: tmp
});
}
try {
parsed += String.fromCodePoint(parseInt(code, 16));
} catch {
throw new TomlError2("invalid unicode escape", {
toml: str,
ptr: tmp
});
}
} else if (isMultiline && (c7 === "\n" || c7 === " " || c7 === " " || c7 === "\r")) {
ptr = skipVoid(str, ptr - 1, true);
if (str[ptr] !== "\n" && str[ptr] !== "\r") {
throw new TomlError2("invalid escape: only line-ending whitespace may be escaped", {
toml: str,
ptr: tmp
});
}
ptr = skipVoid(str, ptr);
} else if (c7 in ESC_MAP) {
parsed += ESC_MAP[c7];
} else {
throw new TomlError2("unrecognized escape sequence", {
toml: str,
ptr: tmp
});
}
sliceStart = ptr;
} else if (!isLiteral && c7 === "\\") {
tmp = ptr - 1;
isEscape = true;
parsed += str.slice(sliceStart, tmp);
}
}
return parsed + str.slice(sliceStart, endPtr - 1);
}
function parseValue(value, toml, ptr, integersAsBigInt) {
if (value === "true")
return true;
if (value === "false")
return false;
if (value === "-inf")
return -Infinity;
if (value === "inf" || value === "+inf")
return Infinity;
if (value === "nan" || value === "+nan" || value === "-nan")
return NaN;
if (value === "-0")
return integersAsBigInt ? 0n : 0;
let isInt = INT_REGEX.test(value);
if (isInt || FLOAT_REGEX.test(value)) {
if (LEADING_ZERO.test(value)) {
throw new TomlError2("leading zeroes are not allowed", {
toml,
ptr
});
}
value = value.replace(/_/g, "");
let numeric = +value;
if (isNaN(numeric)) {
throw new TomlError2("invalid number", {
toml,
ptr
});
}
if (isInt) {
if ((isInt = !Number.isSafeInteger(numeric)) && !integersAsBigInt) {
throw new TomlError2("integer value cannot be represented losslessly", {
toml,
ptr
});
}
if (isInt || integersAsBigInt === true)
numeric = BigInt(value);
}
return numeric;
}
const date = new TomlDate(value);
if (!date.isValid()) {
throw new TomlError2("invalid value", {
toml,
ptr
});
}
return date;
}
function sliceAndTrimEndOf(str, startPtr, endPtr, allowNewLines) {
let value = str.slice(startPtr, endPtr);
let commentIdx = value.indexOf("#");
if (commentIdx > -1) {
skipComment(str, commentIdx);
value = value.slice(0, commentIdx);
}
let trimmed = value.trimEnd();
if (!allowNewLines) {
let newlineIdx = value.indexOf("\n", trimmed.length);
if (newlineIdx > -1) {
throw new TomlError2("newlines are not allowed in inline tables", {
toml: str,
ptr: startPtr + newlineIdx
});
}
}
return [trimmed, commentIdx];
}
function extractValue(str, ptr, end, depth, integersAsBigInt) {
if (depth === 0) {
throw new TomlError2("document contains excessively nested structures. aborting.", {
toml: str,
ptr
});
}
let c7 = str[ptr];
if (c7 === "[" || c7 === "{") {
let [value, endPtr2] = c7 === "[" ? parseArray(str, ptr, depth, integersAsBigInt) : parseInlineTable(str, ptr, depth, integersAsBigInt);
let newPtr = end ? skipUntil(str, endPtr2, ",", end) : endPtr2;
if (endPtr2 - newPtr && end === "}") {
let nextNewLine = indexOfNewline(str, endPtr2, newPtr);
if (nextNewLine > -1) {
throw new TomlError2("newlines are not allowed in inline tables", {
toml: str,
ptr: nextNewLine
});
}
}
return [value, newPtr];
}
let endPtr;
if (c7 === '"' || c7 === "'") {
endPtr = getStringEnd(str, ptr);
let parsed = parseString(str, ptr, endPtr);
if (end) {
endPtr = skipVoid(str, endPtr, end !== "]");
if (str[endPtr] && str[endPtr] !== "," && str[endPtr] !== end && str[endPtr] !== "\n" && str[endPtr] !== "\r") {
throw new TomlError2("unexpected character encountered", {
toml: str,
ptr: endPtr
});
}
endPtr += +(str[endPtr] === ",");
}
return [parsed, endPtr];
}
endPtr = skipUntil(str, ptr, ",", end);
let slice = sliceAndTrimEndOf(str, ptr, endPtr - +(str[endPtr - 1] === ","), end === "]");
if (!slice[0]) {
throw new TomlError2("incomplete key-value declaration: no value specified", {
toml: str,
ptr
});
}
if (end && slice[1] > -1) {
endPtr = skipVoid(str, ptr + slice[1]);
endPtr += +(str[endPtr] === ",");
}
return [
parseValue(slice[0], str, ptr, integersAsBigInt),
endPtr
];
}
function parseKey(str, ptr, end = "=") {
let dot = ptr - 1;
let parsed = [];
let endPtr = str.indexOf(end, ptr);
if (endPtr < 0) {
throw new TomlError2("incomplete key-value: cannot find end of key", {
toml: str,
ptr
});
}
do {
let c7 = str[ptr = ++dot];
if (c7 !== " " && c7 !== " ") {
if (c7 === '"' || c7 === "'") {
if (c7 === str[ptr + 1] && c7 === str[ptr + 2]) {
throw new TomlError2("multiline strings are not allowed in keys", {
toml: str,
ptr
});
}
let eos = getStringEnd(str, ptr);
if (eos < 0) {
throw new TomlError2("unfinished string encountered", {
toml: str,
ptr
});
}
dot = str.indexOf(".", eos);
let strEnd = str.slice(eos, dot < 0 || dot > endPtr ? endPtr : dot);
let newLine = indexOfNewline(strEnd);
if (newLine > -1) {
throw new TomlError2("newlines are not allowed in keys", {
toml: str,
ptr: ptr + dot + newLine
});
}
if (strEnd.trimStart()) {
throw new TomlError2("found extra tokens after the string part", {
toml: str,
ptr: eos
});
}
if (endPtr < eos) {
endPtr = str.indexOf(end, eos);
if (endPtr < 0) {
throw new TomlError2("incomplete key-value: cannot find end of key", {
toml: str,
ptr
});
}
}
parsed.push(parseString(str, ptr, eos));
} else {
dot = str.indexOf(".", ptr);
let part = str.slice(ptr, dot < 0 || dot > endPtr ? endPtr : dot);
if (!KEY_PART_RE.test(part)) {
throw new TomlError2("only letter, numbers, dashes and underscores are allowed in keys", {
toml: str,
ptr
});
}
parsed.push(part.trimEnd());
}
}
} while (dot + 1 && dot < endPtr);
return [parsed, skipVoid(str, endPtr + 1, true, true)];
}
function parseInlineTable(str, ptr, depth, integersAsBigInt) {
let res = {};
let seen = /* @__PURE__ */ new Set();
let c7;
let comma = 0;
ptr++;
while ((c7 = str[ptr++]) !== "}" && c7) {
let err = { toml: str, ptr: ptr - 1 };
if (c7 === "\n") {
throw new TomlError2("newlines are not allowed in inline tables", err);
} else if (c7 === "#") {
throw new TomlError2("inline tables cannot contain comments", err);
} else if (c7 === ",") {
throw new TomlError2("expected key-value, found comma", err);
} else if (c7 !== " " && c7 !== " ") {
let k7;
let t8 = res;
let hasOwn2 = false;
let [key, keyEndPtr] = parseKey(str, ptr - 1);
for (let i6 = 0; i6 < key.length; i6++) {
if (i6)
t8 = hasOwn2 ? t8[k7] : t8[k7] = {};
k7 = key[i6];
if ((hasOwn2 = Object.hasOwn(t8, k7)) && (typeof t8[k7] !== "object" || seen.has(t8[k7]))) {
throw new TomlError2("trying to redefine an already defined value", {
toml: str,
ptr
});
}
if (!hasOwn2 && k7 === "__proto__") {
Object.defineProperty(t8, k7, { enumerable: true, configurable: true, writable: true });
}
}
if (hasOwn2) {
throw new TomlError2("trying to redefine an already defined value", {
toml: str,
ptr
});
}
let [value, valueEndPtr] = extractValue(str, keyEndPtr, "}", depth - 1, integersAsBigInt);
seen.add(value);
t8[k7] = value;
ptr = valueEndPtr;
comma = str[ptr - 1] === "," ? ptr - 1 : 0;
}
}
if (comma) {
throw new TomlError2("trailing commas are not allowed in inline tables", {
toml: str,
ptr: comma
});
}
if (!c7) {
throw new TomlError2("unfinished table encountered", {
toml: str,
ptr
});
}
return [res, ptr];
}
function parseArray(str, ptr, depth, integersAsBigInt) {
let res = [];
let c7;
ptr++;
while ((c7 = str[ptr++]) !== "]" && c7) {
if (c7 === ",") {
throw new TomlError2("expected value, found comma", {
toml: str,
ptr: ptr - 1
});
} else if (c7 === "#")
ptr = skipComment(str, ptr);
else if (c7 !== " " && c7 !== " " && c7 !== "\n" && c7 !== "\r") {
let e8 = extractValue(str, ptr - 1, "]", depth - 1, integersAsBigInt);
res.push(e8[0]);
ptr = e8[1];
}
}
if (!c7) {
throw new TomlError2("unfinished array encountered", {
toml: str,
ptr
});
}
return [res, ptr];
}
function peekTable(key, table, meta, type) {
let t8 = table;
let m7 = meta;
let k7;
let hasOwn2 = false;
let state2;
for (let i6 = 0; i6 < key.length; i6++) {
if (i6) {
t8 = hasOwn2 ? t8[k7] : t8[k7] = {};
m7 = (state2 = m7[k7]).c;
if (type === 0 && (state2.t === 1 || state2.t === 2)) {
return null;
}
if (state2.t === 2) {
let l7 = t8.length - 1;
t8 = t8[l7];
m7 = m7[l7].c;
}
}
k7 = key[i6];
if ((hasOwn2 = Object.hasOwn(t8, k7)) && m7[k7]?.t === 0 && m7[k7]?.d) {
return null;
}
if (!hasOwn2) {
if (k7 === "__proto__") {
Object.defineProperty(t8, k7, { enumerable: true, configurable: true, writable: true });
Object.defineProperty(m7, k7, { enumerable: true, configurable: true, writable: true });
}
m7[k7] = {
t: i6 < key.length - 1 && type === 2 ? 3 : type,
d: false,
i: 0,
c: {}
};
}
}
state2 = m7[k7];
if (state2.t !== type && !(type === 1 && state2.t === 3)) {
return null;
}
if (type === 2) {
if (!state2.d) {
state2.d = true;
t8[k7] = [];
}
t8[k7].push(t8 = {});
state2.c[state2.i++] = state2 = { t: 1, d: false, i: 0, c: {} };
}
if (state2.d) {
return null;
}
state2.d = true;
if (type === 1) {
t8 = hasOwn2 ? t8[k7] : t8[k7] = {};
} else if (type === 0 && hasOwn2) {
return null;
}
return [k7, t8, state2.c];
}
function parse(toml, { maxDepth = 1e3, integersAsBigInt } = {}) {
let res = {};
let meta = {};
let tbl = res;
let m7 = meta;
for (let ptr = skipVoid(toml, 0); ptr < toml.length; ) {
if (toml[ptr] === "[") {
let isTableArray = toml[++ptr] === "[";
let k7 = parseKey(toml, ptr += +isTableArray, "]");
if (isTableArray) {
if (toml[k7[1] - 1] !== "]") {
throw new TomlError2("expected end of table declaration", {
toml,
ptr: k7[1] - 1
});
}
k7[1]++;
}
let p7 = peekTable(
k7[0],
res,
meta,
isTableArray ? 2 : 1
/* Type.EXPLICIT */
);
if (!p7) {
throw new TomlError2("trying to redefine an already defined table or value", {
toml,
ptr
});
}
m7 = p7[2];
tbl = p7[1];
ptr = k7[1];
} else {
let k7 = parseKey(toml, ptr);
let p7 = peekTable(
k7[0],
tbl,
m7,
0
/* Type.DOTTED */
);
if (!p7) {
throw new TomlError2("trying to redefine an already defined table or value", {
toml,
ptr
});
}
let v8 = extractValue(toml, k7[1], void 0, maxDepth, integersAsBigInt);
p7[1][p7[0]] = v8[0];
ptr = v8[1];
}
ptr = skipVoid(toml, ptr, true);
if (toml[ptr] && toml[ptr] !== "\n" && toml[ptr] !== "\r") {
throw new TomlError2("each key-value declaration must be followed by an end-of-line", {
toml,
ptr
});
}
ptr = skipVoid(toml, ptr);
}
return res;
}
function extendedTypeOf(obj) {
let type = typeof obj;
if (type === "object") {
if (Array.isArray(obj))
return "array";
if (obj instanceof Date)
return "date";
}
return type;
}
function isArrayOfTables(obj) {
for (let i6 = 0; i6 < obj.length; i6++) {
if (extendedTypeOf(obj[i6]) !== "object")
return false;
}
return obj.length != 0;
}
function formatString(s6) {
return JSON.stringify(s6).replace(/\x7f/g, "\\u007f");
}
function stringifyValue(val2, type, depth, numberAsFloat) {
if (depth === 0) {
throw new Error("Could not stringify the object: maximum object depth exceeded");
}
if (type === "number") {
if (isNaN(val2))
return "nan";
if (val2 === Infinity)
return "inf";
if (val2 === -Infinity)
return "-inf";
if (numberAsFloat && Number.isInteger(val2))
return val2.toFixed(1);
return val2.toString();
}
if (type === "bigint" || type === "boolean") {
return val2.toString();
}
if (type === "string") {
return formatString(val2);
}
if (type === "date") {
if (isNaN(val2.getTime())) {
throw new TypeError("cannot serialize invalid date");
}
return val2.toISOString();
}
if (type === "object") {
return stringifyInlineTable(val2, depth, numberAsFloat);
}
if (type === "array") {
return stringifyArray(val2, depth, numberAsFloat);
}
}
function stringifyInlineTable(obj, depth, numberAsFloat) {
let keys = Object.keys(obj);
if (keys.length === 0)
return "{}";
let res = "{ ";
for (let i6 = 0; i6 < keys.length; i6++) {
let k7 = keys[i6];
if (i6)
res += ", ";
res += BARE_KEY.test(k7) ? k7 : formatString(k7);
res += " = ";
res += stringifyValue(obj[k7], extendedTypeOf(obj[k7]), depth - 1, numberAsFloat);
}
return res + " }";
}
function stringifyArray(array, depth, numberAsFloat) {
if (array.length === 0)
return "[]";
let res = "[ ";
for (let i6 = 0; i6 < array.length; i6++) {
if (i6)
res += ", ";
if (array[i6] === null || array[i6] === void 0) {
throw new TypeError("arrays cannot contain null or undefined values");
}
res += stringifyValue(array[i6], extendedTypeOf(array[i6]), depth - 1, numberAsFloat);
}
return res + " ]";
}
function stringifyArrayTable(array, key, depth, numberAsFloat) {
if (depth === 0) {
throw new Error("Could not stringify the object: maximum object depth exceeded");
}
let res = "";
for (let i6 = 0; i6 < array.length; i6++) {
res += `${res && "\n"}[[${key}]]
`;
res += stringifyTable(0, array[i6], key, depth, numberAsFloat);
}
return res;
}
function stringifyTable(tableKey, obj, prefix, depth, numberAsFloat) {
if (depth === 0) {
throw new Error("Could not stringify the object: maximum object depth exceeded");
}
let preamble = "";
let tables = "";
let keys = Object.keys(obj);
for (let i6 = 0; i6 < keys.length; i6++) {
let k7 = keys[i6];
if (obj[k7] !== null && obj[k7] !== void 0) {
let type = extendedTypeOf(obj[k7]);
if (type === "symbol" || type === "function") {
throw new TypeError(`cannot serialize values of type '${type}'`);
}
let key = BARE_KEY.test(k7) ? k7 : formatString(k7);
if (type === "array" && isArrayOfTables(obj[k7])) {
tables += (tables && "\n") + stringifyArrayTable(obj[k7], prefix ? `${prefix}.${key}` : key, depth - 1, numberAsFloat);
} else if (type === "object") {
let tblKey = prefix ? `${prefix}.${key}` : key;
tables += (tables && "\n") + stringifyTable(tblKey, obj[k7], tblKey, depth - 1, numberAsFloat);
} else {
preamble += key;
preamble += " = ";
preamble += stringifyValue(obj[k7], type, depth, numberAsFloat);
preamble += "\n";
}
}
}
if (tableKey && (preamble || !tables))
preamble = preamble ? `[${tableKey}]
${preamble}` : `[${tableKey}]`;
return preamble && tables ? `${preamble}
${tables}` : preamble || tables;
}
function stringify(obj, { maxDepth = 1e3, numbersAsFloat = false } = {}) {
if (extendedTypeOf(obj) !== "object") {
throw new TypeError("stringify can only be called with an object");
}
let str = stringifyTable(0, obj, "", maxDepth, numbersAsFloat);
if (str[str.length - 1] !== "\n")
return str + "\n";
return str;
}
function createScanner(text, ignoreTrivia = false) {
const len = text.length;
let pos = 0, value = "", tokenOffset = 0, token = 16, lineNumber = 0, lineStartOffset = 0, tokenLineStartOffset = 0, prevTokenLineStartOffset = 0, scanError = 0;
function scanHexDigits(count, exact) {
let digits2 = 0;
let value2 = 0;
while (digits2 < count || !exact) {
let ch2 = text.charCodeAt(pos);
if (ch2 >= 48 && ch2 <= 57) {
value2 = value2 * 16 + ch2 - 48;
} else if (ch2 >= 65 && ch2 <= 70) {
value2 = value2 * 16 + ch2 - 65 + 10;
} else if (ch2 >= 97 && ch2 <= 102) {
value2 = value2 * 16 + ch2 - 97 + 10;
} else {
break;
}
pos++;
digits2++;
}
if (digits2 < count) {
value2 = -1;
}
return value2;
}
__name(scanHexDigits, "scanHexDigits");
__name2(scanHexDigits, "scanHexDigits");
function setPosition(newPosition) {
pos = newPosition;
value = "";
tokenOffset = 0;
token = 16;
scanError = 0;
}
__name(setPosition, "setPosition");
__name2(setPosition, "setPosition");
function scanNumber() {
let start = pos;
if (text.charCodeAt(pos) === 48) {
pos++;
} else {
pos++;
while (pos < text.length && isDigit2(text.charCodeAt(pos))) {
pos++;
}
}
if (pos < text.length && text.charCodeAt(pos) === 46) {
pos++;
if (pos < text.length && isDigit2(text.charCodeAt(pos))) {
pos++;
while (pos < text.length && isDigit2(text.charCodeAt(pos))) {
pos++;
}
} else {
scanError = 3;
return text.substring(start, pos);
}
}
let end = pos;
if (pos < text.length && (text.charCodeAt(pos) === 69 || text.charCodeAt(pos) === 101)) {
pos++;
if (pos < text.length && text.charCodeAt(pos) === 43 || text.charCodeAt(pos) === 45) {
pos++;
}
if (pos < text.length && isDigit2(text.charCodeAt(pos))) {
pos++;
while (pos < text.length && isDigit2(text.charCodeAt(pos))) {
pos++;
}
end = pos;
} else {
scanError = 3;
}
}
return text.substring(start, end);
}
__name(scanNumber, "scanNumber");
__name2(scanNumber, "scanNumber");
function scanString() {
let result = "", start = pos;
while (true) {
if (pos >= len) {
result += text.substring(start, pos);
scanError = 2;
break;
}
const ch2 = text.charCodeAt(pos);
if (ch2 === 34) {
result += text.substring(start, pos);
pos++;
break;
}
if (ch2 === 92) {
result += text.substring(start, pos);
pos++;
if (pos >= len) {
scanError = 2;
break;
}
const ch22 = text.charCodeAt(pos++);
switch (ch22) {
case 34:
result += '"';
break;
case 92:
result += "\\";
break;
case 47:
result += "/";
break;
case 98:
result += "\b";
break;
case 102:
result += "\f";
break;
case 110:
result += "\n";
break;
case 114:
result += "\r";
break;
case 116:
result += " ";
break;
case 117:
const ch3 = scanHexDigits(4, true);
if (ch3 >= 0) {
result += String.fromCharCode(ch3);
} else {
scanError = 4;
}
break;
default:
scanError = 5;
}
start = pos;
continue;
}
if (ch2 >= 0 && ch2 <= 31) {
if (isLineBreak(ch2)) {
result += text.substring(start, pos);
scanError = 2;
break;
} else {
scanError = 6;
}
}
pos++;
}
return result;
}
__name(scanString, "scanString");
__name2(scanString, "scanString");
function scanNext() {
value = "";
scanError = 0;
tokenOffset = pos;
lineStartOffset = lineNumber;
prevTokenLineStartOffset = tokenLineStartOffset;
if (pos >= len) {
tokenOffset = len;
return token = 17;
}
let code = text.charCodeAt(pos);
if (isWhiteSpace(code)) {
do {
pos++;
value += String.fromCharCode(code);
code = text.charCodeAt(pos);
} while (isWhiteSpace(code));
return token = 15;
}
if (isLineBreak(code)) {
pos++;
value += String.fromCharCode(code);
if (code === 13 && text.charCodeAt(pos) === 10) {
pos++;
value += "\n";
}
lineNumber++;
tokenLineStartOffset = pos;
return token = 14;
}
switch (code) {
// tokens: []{}:,
case 123:
pos++;
return token = 1;
case 125:
pos++;
return token = 2;
case 91:
pos++;
return token = 3;
case 93:
pos++;
return token = 4;
case 58:
pos++;
return token = 6;
case 44:
pos++;
return token = 5;
// strings
case 34:
pos++;
value = scanString();
return token = 10;
// comments
case 47:
const start = pos - 1;
if (text.charCodeAt(pos + 1) === 47) {
pos += 2;
while (pos < len) {
if (isLineBreak(text.charCodeAt(pos))) {
break;
}
pos++;
}
value = text.substring(start, pos);
return token = 12;
}
if (text.charCodeAt(pos + 1) === 42) {
pos += 2;
const safeLength = len - 1;
let commentClosed = false;
while (pos < safeLength) {
const ch2 = text.charCodeAt(pos);
if (ch2 === 42 && text.charCodeAt(pos + 1) === 47) {
pos += 2;
commentClosed = true;
break;
}
pos++;
if (isLineBreak(ch2)) {
if (ch2 === 13 && text.charCodeAt(pos) === 10) {
pos++;
}
lineNumber++;
tokenLineStartOffset = pos;
}
}
if (!commentClosed) {
pos++;
scanError = 1;
}
value = text.substring(start, pos);
return token = 13;
}
value += String.fromCharCode(code);
pos++;
return token = 16;
// numbers
case 45:
value += String.fromCharCode(code);
pos++;
if (pos === len || !isDigit2(text.charCodeAt(pos))) {
return token = 16;
}
// found a minus, followed by a number so
// we fall through to proceed with scanning
// numbers
case 48:
case 49:
case 50:
case 51:
case 52:
case 53:
case 54:
case 55:
case 56:
case 57:
value += scanNumber();
return token = 11;
// literals and unknown