vinext 1.3.0 → 1.4.0

package/dist/config/next-config.js

@@ -1,4 +1,5 @@
 import path, { toSlash } from "../deps/.pnpm/pathslash@0.1.0/deps/pathslash/dist/index.js";
+import { escapeRegExp } from "../utils/regex.js";
 import { DEFAULT_PAGE_EXTENSIONS, normalizePageExtensions } from "../routing/file-matcher.js";
 import { loadCommonJsModule, shouldRetryAsCommonJs } from "../utils/commonjs-loader.js";
 import { isUnknownRecord } from "../utils/record.js";
@@ -374,7 +375,8 @@ function warnDeprecatedConfigOptions(config, root) {
 		["experimental.instrumentationHook", `\`experimental.instrumentationHook\` is no longer needed, because \`instrumentation.js\` is available by default. You can remove it from ${configFileName}.`]
 	];
 	for (const [propertyPath, warning] of warnings) if (hasConfigProperty(config, propertyPath)) warnConfigOnce(warning);
-	if (readOptionalRecord(config.experimental)?.skipTrailingSlashRedirect != null) warnConfigOnce(`\`experimental.skipTrailingSlashRedirect\` has been moved to \`skipTrailingSlashRedirect\`. Please update your ${configFileName} file accordingly.`);
+	const experimental = readOptionalRecord(config.experimental);
+	for (const key of ["skipTrailingSlashRedirect", "cacheComponents"]) if (experimental?.[key] != null) warnConfigOnce(`\`experimental.${key}\` has been moved to \`${key}\`. Please update your ${configFileName} file accordingly.`);
 }
 async function resolveNextConfigInput(config, phase = PHASE_DEVELOPMENT_SERVER) {
 	return await resolveConfigValue(config, phase);
@@ -808,6 +810,28 @@ function validateConfigConditions(type, routes) {
 	}
 	if (invalid.length > 0) throw new Error(`Invalid next.config.js ${type} has/missing condition${invalid.length === 1 ? "" : "s"}:\n${invalid.join("\n")}\nEach item must be { type: header, cookie, query or host, key: string, value?: string }, with a value and no key required for host.`);
 }
+const REDIRECT_STATUS_CODES = /* @__PURE__ */ new Set([
+	301,
+	302,
+	303,
+	307,
+	308
+]);
+/**
+* Fail config loading on a redirect without a valid status, with the rules of
+* Next.js's checkRedirect (load-custom-routes.ts): `statusCode` must be one of
+* the redirect statuses, and `permanent` a boolean when it is absent.
+*/
+function validateRedirectStatuses(redirects) {
+	const invalid = [];
+	for (const redirect of redirects) {
+		const parts = [];
+		if (redirect.statusCode && !REDIRECT_STATUS_CODES.has(redirect.statusCode)) parts.push("`statusCode` is not undefined or valid statusCode");
+		if (typeof redirect.permanent !== "boolean" && !redirect.statusCode) parts.push("`permanent` is not set to `true` or `false`");
+		if (parts.length > 0) invalid.push(`  ${describeSource(redirect.source)}: ${parts.join(", ")}`);
+	}
+	if (invalid.length > 0) throw new Error(`Invalid next.config.js redirect${invalid.length === 1 ? "" : "s"}:\n${invalid.join("\n")}\nValid redirect statusCode values are ${[...REDIRECT_STATUS_CODES].join(", ")}`);
+}
 /** JSON for a config value, or its type when JSON cannot serialize it. */
 function describeConfigValue(value) {
 	try {
@@ -861,6 +885,7 @@ async function resolveNextConfig(config, root = toSlash(process.cwd()), options
 			resolveExtensions: null,
 			serverResolveExtensions: null,
 			cacheComponents: false,
+			cachedNavigations: false,
 			appNavFailHandling: false,
 			gestureTransition: false,
 			prefetchInlining: false,
@@ -874,6 +899,7 @@ async function resolveNextConfig(config, root = toSlash(process.cwd()), options
 			images: void 0,
 			i18n: null,
 			mdx: null,
+			nextIntlCatalogLoader: null,
 			aliases: {},
 			allowedDevOrigins: [],
 			serverActionsAllowedOrigins: [],
@@ -950,6 +976,7 @@ async function resolveNextConfig(config, root = toSlash(process.cwd()), options
 		validateConfigSources("redirect", redirects);
 		validateConfigSources("rewrite", allRewrites);
 		validateConfigConditions("redirect", redirects);
+		validateRedirectStatuses(redirects);
 		validateConfigConditions("rewrite", allRewrites);
 		const invalidBasePathRewrites = allRewrites.filter((rewrite) => rewrite.basePath === false && !(rewrite.destination.startsWith("http://") || rewrite.destination.startsWith("https://")));
 		if (invalidBasePathRewrites.length > 0) throw new Error(invalidBasePathRewrites.map((rewrite) => `The route ${rewrite.source} rewrites urls outside of the basePath. Please use a destination that starts with \`http://\` or \`https://\` https://nextjs.org/docs/messages/invalid-external-rewrite`).concat(`Invalid rewrite${invalidBasePathRewrites.length === 1 ? "" : "s"} found`).join("\n"));
@@ -986,6 +1013,7 @@ async function resolveNextConfig(config, root = toSlash(process.cwd()), options
 	};
 	const allowedDevOrigins = Array.isArray(config.allowedDevOrigins) ? config.allowedDevOrigins : [];
 	const experimental = readOptionalRecord(config.experimental);
+	const cacheComponents = (experimental?.cacheComponents ?? config.cacheComponents) === true;
 	const serverActionsConfig = readOptionalRecord(experimental?.serverActions);
 	const serverActionsAllowedOrigins = readStringArray(serverActionsConfig?.allowedOrigins);
 	const serverActionsBodySizeLimitConfig = readOptionalBodySizeLimit(serverActionsConfig?.bodySizeLimit);
@@ -1001,7 +1029,7 @@ async function resolveNextConfig(config, root = toSlash(process.cwd()), options
 	const appShells = experimental?.appShells === true;
 	if (appShells) {
 		const missingCoFlags = [];
-		if (!config.cacheComponents) missingCoFlags.push("cacheComponents");
+		if (!cacheComponents) missingCoFlags.push("cacheComponents");
 		if (!prefetchInlining) missingCoFlags.push("experimental.prefetchInlining");
 		if (experimental?.varyParams !== true) missingCoFlags.push("experimental.varyParams");
 		if (experimental?.optimisticRouting !== true) missingCoFlags.push("experimental.optimisticRouting");
@@ -1022,9 +1050,9 @@ async function resolveNextConfig(config, root = toSlash(process.cwd()), options
 		exclude: lightningCssFeatureNamesToMask(readStringArray(rawLightningCssFeatures?.exclude))
 	};
 	if (rawLightningCssFeatures && !useLightningcss) console.warn("[vinext] experimental.lightningCssFeatures is set but experimental.useLightningcss is not enabled. The lightningCssFeatures option has no effect without useLightningcss.");
-	if (experimental?.cachedNavigations === true && !config.cacheComponents) console.warn("[vinext] `experimental.cachedNavigations` requires `cacheComponents: true` to have any effect. Set `cacheComponents: true` in your next.config, or remove `experimental.cachedNavigations`.");
+	if (experimental?.cachedNavigations === true && !cacheComponents) console.warn("[vinext] `experimental.cachedNavigations` requires `cacheComponents: true` to have any effect. Set `cacheComponents: true` in your next.config, or remove `experimental.cachedNavigations`.");
 	if (config.webpack !== void 0) {
-		if (mdx || Object.keys(webpackProbe.aliases).length > 0 || webpackProbe.resolveExtensionsCustomized || webpackProbe.instrumentationClientRouteManifest !== void 0) console.warn("[vinext] next.config option \"webpack\" is only partially supported. vinext preserves resolve.alias, resolve.extensions, MDX loader settings, and instrumentation-client route manifests, but other webpack customization is ignored");
+		if (mdx || Object.keys(webpackProbe.aliases).length > 0 || webpackProbe.resolveExtensionsCustomized || webpackProbe.instrumentationClientRouteManifest !== void 0 || webpackProbe.nextIntlCatalogLoader !== null) console.warn("[vinext] next.config option \"webpack\" is only partially supported. vinext preserves resolve.alias, resolve.extensions, MDX loader settings, next-intl message catalog loaders, and instrumentation-client route manifests, but other webpack customization is ignored");
 		else console.warn("[vinext] next.config option \"webpack\" is not yet supported and will be ignored");
 	}
 	const output = readOptionalString(config.output) ?? "";
@@ -1073,7 +1101,8 @@ async function resolveNextConfig(config, root = toSlash(process.cwd()), options
 		instrumentationClientInject: Array.isArray(config.instrumentationClientInject) ? config.instrumentationClientInject.filter((x) => typeof x === "string") : [],
 		instrumentationClientRouteManifest: webpackProbe.instrumentationClientRouteManifest,
 		instrumentationServerValueInjections: webpackProbe.instrumentationServerValueInjections,
-		cacheComponents: config.cacheComponents ?? false,
+		cacheComponents,
+		cachedNavigations: cacheComponents && experimental?.cachedNavigations === true,
 		appNavFailHandling: experimental?.appNavFailHandling === true,
 		gestureTransition: experimental?.gestureTransition === true,
 		prefetchInlining,
@@ -1083,6 +1112,7 @@ async function resolveNextConfig(config, root = toSlash(process.cwd()), options
 		images,
 		i18n,
 		mdx,
+		nextIntlCatalogLoader: webpackProbe.nextIntlCatalogLoader ?? extractTurbopackNextIntlCatalogLoader(config, root),
 		aliases,
 		allowedDevOrigins,
 		serverActionsAllowedOrigins,
@@ -1119,6 +1149,7 @@ async function resolveNextConfig(config, root = toSlash(process.cwd()), options
 		lightningCssFeatures
 	};
 	detectNextIntlConfig(root, resolved);
+	if (resolved.aliases["use-intl/format-message"]?.includes("format-only") && resolved.nextIntlCatalogLoader === null) console.warn("[vinext] next-intl's `experimental.messages.precompile` is enabled, but vinext could not find next-intl's catalog loader in the webpack or Turbopack config. Messages with arguments or rich text will render their raw ICU source; remove `precompile` to format them at runtime");
 	if (resolved.basePath !== "" && resolved.basePath !== "/" && resolved.assetPrefix === "") resolved.assetPrefix = resolved.basePath;
 	return resolved;
 }
@@ -1155,10 +1186,36 @@ function extractTurboAliases(config, root) {
 		...normalizeAliasEntries(readOptionalRecord(topLevelTurbopack?.resolveAlias), root)
 	};
 }
+function extractTurbopackNextIntlCatalogLoader(config, root) {
+	const experimental = readOptionalRecord(config.experimental);
+	for (const turbo of [readOptionalRecord(config.turbopack), readOptionalRecord(experimental?.turbo)]) {
+		const rules = readOptionalRecord(turbo?.rules);
+		for (const [glob, entry] of Object.entries(rules ?? {})) {
+			const extension = /^\*(\.[^*/{}]+)$/.exec(glob)?.[1];
+			if (!extension) continue;
+			for (const rule of Array.isArray(entry) ? entry : [entry]) {
+				if (!isUnknownRecord(rule) || !Array.isArray(rule.loaders)) continue;
+				const loader = rule.loaders.find((use) => isUnknownRecord(use) && use.loader === NEXT_INTL_CATALOG_LOADER);
+				if (!isUnknownRecord(loader) || !isUnknownRecord(loader.options)) continue;
+				const condition = readOptionalRecord(rule.condition);
+				const dirs = typeof condition?.path === "string" ? /^(?:\{([^{}]+)\}|([^{}]+))\/\*\*\/\*$/.exec(condition.path) : null;
+				const include = (dirs?.[1]?.split(",") ?? (dirs?.[2] ? [dirs[2]] : [])).map((dir) => path.resolve(root, dir));
+				if (include.length === 0) continue;
+				return {
+					include,
+					test: new RegExp(`${escapeRegExp(extension)}$`),
+					options: loader.options
+				};
+			}
+		}
+	}
+	return null;
+}
 async function probeWebpackConfig(config, root, dev) {
 	if (typeof config.webpack !== "function") return {
 		aliases: {},
 		mdx: null,
+		nextIntlCatalogLoader: null,
 		resolveExtensions: null,
 		serverResolveExtensions: null,
 		resolveExtensionsCustomized: false,
@@ -1179,6 +1236,7 @@ async function probeWebpackConfig(config, root, dev) {
 		return {
 			aliases: normalizeAliasEntries(clientProbe.config.resolve?.alias, root),
 			mdx: extractMdxOptionsFromRules(clientProbe.rules),
+			nextIntlCatalogLoader: extractNextIntlCatalogLoader(clientProbe.rules),
 			resolveExtensions: clientProbe.resolveExtensions,
 			serverResolveExtensions: serverProbe.resolveExtensions,
 			resolveExtensionsCustomized: clientProbe.resolveExtensions !== null || serverProbe.resolveExtensions !== null,
@@ -1189,6 +1247,7 @@ async function probeWebpackConfig(config, root, dev) {
 		return {
 			aliases: {},
 			mdx: null,
+			nextIntlCatalogLoader: null,
 			resolveExtensions: null,
 			serverResolveExtensions: null,
 			resolveExtensionsCustomized: false,
@@ -1221,6 +1280,35 @@ function extractInstrumentationClientRouteManifest(rules) {
 	for (const rule of rules) visit(rule);
 	return manifest;
 }
+const NEXT_INTL_CATALOG_LOADER = "next-intl/extractor/catalogLoader";
+function extractNextIntlCatalogLoader(rules) {
+	let catalogLoader = null;
+	const visit = (rule) => {
+		if (!rule || typeof rule !== "object") return;
+		if (Array.isArray(rule)) {
+			for (const child of rule) visit(child);
+			return;
+		}
+		if (Array.isArray(rule.oneOf)) for (const child of rule.oneOf) visit(child);
+		if (Array.isArray(rule.rules)) for (const child of rule.rules) visit(child);
+		if (!(rule.test instanceof RegExp)) return;
+		const include = typeof rule.include === "string" ? [rule.include] : rule.include;
+		if (!Array.isArray(include) || include.length === 0) return;
+		if (!include.every((dir) => typeof dir === "string")) return;
+		const uses = Array.isArray(rule.use) ? rule.use : rule.use ? [rule.use] : [];
+		for (const use of uses) {
+			if (!isUnknownRecord(use) || use.loader !== NEXT_INTL_CATALOG_LOADER) continue;
+			if (!isUnknownRecord(use.options)) continue;
+			catalogLoader = {
+				include,
+				test: rule.test,
+				options: use.options
+			};
+		}
+	};
+	for (const rule of rules) visit(rule);
+	return catalogLoader;
+}
 function matchesWebpackCondition(condition, value) {
 	if (typeof condition === "string") return value.startsWith(condition);
 	if (condition instanceof RegExp) {

package/dist/config/tsconfig-paths.d.ts

@@ -17,4 +17,5 @@ export declare function loadTsconfigResolutionForRoot(projectRoot: string): Tsco
  * Back-compat helper for call sites that only need `compilerOptions.paths`.
  */
 export declare function loadTsconfigPathAliasesForRoot(projectRoot: string): Record<string, string>;
-//#endregion
+//#endregion
+export {};

package/dist/deps/.pnpm/iconv-lite@0.4.24/deps/iconv-lite/encodings/dbcs-codec.js

@@ -0,0 +1,327 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.js";
+import { require_safer } from "../../../../safer-buffer@2.1.2/deps/safer-buffer/safer.js";
+//#region ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/dbcs-codec.js
+var require_dbcs_codec = /* @__PURE__ */ __commonJSMin(((exports) => {
+	var Buffer = require_safer().Buffer;
+	exports._dbcs = DBCSCodec;
+	var UNASSIGNED = -1;
+	var GB18030_CODE = -2;
+	var SEQ_START = -10;
+	var NODE_START = -1e3;
+	var UNASSIGNED_NODE = new Array(256);
+	var DEF_CHAR = -1;
+	for (var i = 0; i < 256; i++) UNASSIGNED_NODE[i] = UNASSIGNED;
+	function DBCSCodec(codecOptions, iconv) {
+		this.encodingName = codecOptions.encodingName;
+		if (!codecOptions) throw new Error("DBCS codec is called without the data.");
+		if (!codecOptions.table) throw new Error("Encoding '" + this.encodingName + "' has no data.");
+		var mappingTable = codecOptions.table();
+		this.decodeTables = [];
+		this.decodeTables[0] = UNASSIGNED_NODE.slice(0);
+		this.decodeTableSeq = [];
+		for (var i = 0; i < mappingTable.length; i++) this._addDecodeChunk(mappingTable[i]);
+		this.defaultCharUnicode = iconv.defaultCharUnicode;
+		this.encodeTable = [];
+		this.encodeTableSeq = [];
+		var skipEncodeChars = {};
+		if (codecOptions.encodeSkipVals) for (var i = 0; i < codecOptions.encodeSkipVals.length; i++) {
+			var val = codecOptions.encodeSkipVals[i];
+			if (typeof val === "number") skipEncodeChars[val] = true;
+			else for (var j = val.from; j <= val.to; j++) skipEncodeChars[j] = true;
+		}
+		this._fillEncodeTable(0, 0, skipEncodeChars);
+		if (codecOptions.encodeAdd) {
+			for (var uChar in codecOptions.encodeAdd) if (Object.prototype.hasOwnProperty.call(codecOptions.encodeAdd, uChar)) this._setEncodeChar(uChar.charCodeAt(0), codecOptions.encodeAdd[uChar]);
+		}
+		this.defCharSB = this.encodeTable[0][iconv.defaultCharSingleByte.charCodeAt(0)];
+		if (this.defCharSB === UNASSIGNED) this.defCharSB = this.encodeTable[0]["?"];
+		if (this.defCharSB === UNASSIGNED) this.defCharSB = "?".charCodeAt(0);
+		if (typeof codecOptions.gb18030 === "function") {
+			this.gb18030 = codecOptions.gb18030();
+			var thirdByteNodeIdx = this.decodeTables.length;
+			var thirdByteNode = this.decodeTables[thirdByteNodeIdx] = UNASSIGNED_NODE.slice(0);
+			var fourthByteNodeIdx = this.decodeTables.length;
+			var fourthByteNode = this.decodeTables[fourthByteNodeIdx] = UNASSIGNED_NODE.slice(0);
+			for (var i = 129; i <= 254; i++) {
+				var secondByteNodeIdx = NODE_START - this.decodeTables[0][i];
+				var secondByteNode = this.decodeTables[secondByteNodeIdx];
+				for (var j = 48; j <= 57; j++) secondByteNode[j] = NODE_START - thirdByteNodeIdx;
+			}
+			for (var i = 129; i <= 254; i++) thirdByteNode[i] = NODE_START - fourthByteNodeIdx;
+			for (var i = 48; i <= 57; i++) fourthByteNode[i] = GB18030_CODE;
+		}
+	}
+	DBCSCodec.prototype.encoder = DBCSEncoder;
+	DBCSCodec.prototype.decoder = DBCSDecoder;
+	DBCSCodec.prototype._getDecodeTrieNode = function(addr) {
+		var bytes = [];
+		for (; addr > 0; addr >>= 8) bytes.push(addr & 255);
+		if (bytes.length == 0) bytes.push(0);
+		var node = this.decodeTables[0];
+		for (var i = bytes.length - 1; i > 0; i--) {
+			var val = node[bytes[i]];
+			if (val == UNASSIGNED) {
+				node[bytes[i]] = NODE_START - this.decodeTables.length;
+				this.decodeTables.push(node = UNASSIGNED_NODE.slice(0));
+			} else if (val <= NODE_START) node = this.decodeTables[NODE_START - val];
+			else throw new Error("Overwrite byte in " + this.encodingName + ", addr: " + addr.toString(16));
+		}
+		return node;
+	};
+	DBCSCodec.prototype._addDecodeChunk = function(chunk) {
+		var curAddr = parseInt(chunk[0], 16);
+		var writeTable = this._getDecodeTrieNode(curAddr);
+		curAddr = curAddr & 255;
+		for (var k = 1; k < chunk.length; k++) {
+			var part = chunk[k];
+			if (typeof part === "string") for (var l = 0; l < part.length;) {
+				var code = part.charCodeAt(l++);
+				if (55296 <= code && code < 56320) {
+					var codeTrail = part.charCodeAt(l++);
+					if (56320 <= codeTrail && codeTrail < 57344) writeTable[curAddr++] = 65536 + (code - 55296) * 1024 + (codeTrail - 56320);
+					else throw new Error("Incorrect surrogate pair in " + this.encodingName + " at chunk " + chunk[0]);
+				} else if (4080 < code && code <= 4095) {
+					var len = 4095 - code + 2;
+					var seq = [];
+					for (var m = 0; m < len; m++) seq.push(part.charCodeAt(l++));
+					writeTable[curAddr++] = SEQ_START - this.decodeTableSeq.length;
+					this.decodeTableSeq.push(seq);
+				} else writeTable[curAddr++] = code;
+			}
+			else if (typeof part === "number") {
+				var charCode = writeTable[curAddr - 1] + 1;
+				for (var l = 0; l < part; l++) writeTable[curAddr++] = charCode++;
+			} else throw new Error("Incorrect type '" + typeof part + "' given in " + this.encodingName + " at chunk " + chunk[0]);
+		}
+		if (curAddr > 255) throw new Error("Incorrect chunk in " + this.encodingName + " at addr " + chunk[0] + ": too long" + curAddr);
+	};
+	DBCSCodec.prototype._getEncodeBucket = function(uCode) {
+		var high = uCode >> 8;
+		if (this.encodeTable[high] === void 0) this.encodeTable[high] = UNASSIGNED_NODE.slice(0);
+		return this.encodeTable[high];
+	};
+	DBCSCodec.prototype._setEncodeChar = function(uCode, dbcsCode) {
+		var bucket = this._getEncodeBucket(uCode);
+		var low = uCode & 255;
+		if (bucket[low] <= SEQ_START) this.encodeTableSeq[SEQ_START - bucket[low]][DEF_CHAR] = dbcsCode;
+		else if (bucket[low] == UNASSIGNED) bucket[low] = dbcsCode;
+	};
+	DBCSCodec.prototype._setEncodeSequence = function(seq, dbcsCode) {
+		var uCode = seq[0];
+		var bucket = this._getEncodeBucket(uCode);
+		var low = uCode & 255;
+		var node;
+		if (bucket[low] <= SEQ_START) node = this.encodeTableSeq[SEQ_START - bucket[low]];
+		else {
+			node = {};
+			if (bucket[low] !== UNASSIGNED) node[DEF_CHAR] = bucket[low];
+			bucket[low] = SEQ_START - this.encodeTableSeq.length;
+			this.encodeTableSeq.push(node);
+		}
+		for (var j = 1; j < seq.length - 1; j++) {
+			var oldVal = node[uCode];
+			if (typeof oldVal === "object") node = oldVal;
+			else {
+				node = node[uCode] = {};
+				if (oldVal !== void 0) node[DEF_CHAR] = oldVal;
+			}
+		}
+		uCode = seq[seq.length - 1];
+		node[uCode] = dbcsCode;
+	};
+	DBCSCodec.prototype._fillEncodeTable = function(nodeIdx, prefix, skipEncodeChars) {
+		var node = this.decodeTables[nodeIdx];
+		for (var i = 0; i < 256; i++) {
+			var uCode = node[i];
+			var mbCode = prefix + i;
+			if (skipEncodeChars[mbCode]) continue;
+			if (uCode >= 0) this._setEncodeChar(uCode, mbCode);
+			else if (uCode <= NODE_START) this._fillEncodeTable(NODE_START - uCode, mbCode << 8, skipEncodeChars);
+			else if (uCode <= SEQ_START) this._setEncodeSequence(this.decodeTableSeq[SEQ_START - uCode], mbCode);
+		}
+	};
+	function DBCSEncoder(options, codec) {
+		this.leadSurrogate = -1;
+		this.seqObj = void 0;
+		this.encodeTable = codec.encodeTable;
+		this.encodeTableSeq = codec.encodeTableSeq;
+		this.defaultCharSingleByte = codec.defCharSB;
+		this.gb18030 = codec.gb18030;
+	}
+	DBCSEncoder.prototype.write = function(str) {
+		var newBuf = Buffer.alloc(str.length * (this.gb18030 ? 4 : 3)), leadSurrogate = this.leadSurrogate, seqObj = this.seqObj, nextChar = -1, i = 0, j = 0;
+		while (true) {
+			if (nextChar === -1) {
+				if (i == str.length) break;
+				var uCode = str.charCodeAt(i++);
+			} else {
+				var uCode = nextChar;
+				nextChar = -1;
+			}
+			if (55296 <= uCode && uCode < 57344) {
+				if (uCode < 56320) {
+					if (leadSurrogate === -1) {
+						leadSurrogate = uCode;
+						continue;
+					} else {
+						leadSurrogate = uCode;
+						uCode = UNASSIGNED;
+					}
+				} else if (leadSurrogate !== -1) {
+					uCode = 65536 + (leadSurrogate - 55296) * 1024 + (uCode - 56320);
+					leadSurrogate = -1;
+				} else uCode = UNASSIGNED;
+			} else if (leadSurrogate !== -1) {
+				nextChar = uCode;
+				uCode = UNASSIGNED;
+				leadSurrogate = -1;
+			}
+			var dbcsCode = UNASSIGNED;
+			if (seqObj !== void 0 && uCode != UNASSIGNED) {
+				var resCode = seqObj[uCode];
+				if (typeof resCode === "object") {
+					seqObj = resCode;
+					continue;
+				} else if (typeof resCode == "number") dbcsCode = resCode;
+				else if (resCode == void 0) {
+					resCode = seqObj[DEF_CHAR];
+					if (resCode !== void 0) {
+						dbcsCode = resCode;
+						nextChar = uCode;
+					}
+				}
+				seqObj = void 0;
+			} else if (uCode >= 0) {
+				var subtable = this.encodeTable[uCode >> 8];
+				if (subtable !== void 0) dbcsCode = subtable[uCode & 255];
+				if (dbcsCode <= SEQ_START) {
+					seqObj = this.encodeTableSeq[SEQ_START - dbcsCode];
+					continue;
+				}
+				if (dbcsCode == UNASSIGNED && this.gb18030) {
+					var idx = findIdx(this.gb18030.uChars, uCode);
+					if (idx != -1) {
+						var dbcsCode = this.gb18030.gbChars[idx] + (uCode - this.gb18030.uChars[idx]);
+						newBuf[j++] = 129 + Math.floor(dbcsCode / 12600);
+						dbcsCode = dbcsCode % 12600;
+						newBuf[j++] = 48 + Math.floor(dbcsCode / 1260);
+						dbcsCode = dbcsCode % 1260;
+						newBuf[j++] = 129 + Math.floor(dbcsCode / 10);
+						dbcsCode = dbcsCode % 10;
+						newBuf[j++] = 48 + dbcsCode;
+						continue;
+					}
+				}
+			}
+			if (dbcsCode === UNASSIGNED) dbcsCode = this.defaultCharSingleByte;
+			if (dbcsCode < 256) newBuf[j++] = dbcsCode;
+			else if (dbcsCode < 65536) {
+				newBuf[j++] = dbcsCode >> 8;
+				newBuf[j++] = dbcsCode & 255;
+			} else {
+				newBuf[j++] = dbcsCode >> 16;
+				newBuf[j++] = dbcsCode >> 8 & 255;
+				newBuf[j++] = dbcsCode & 255;
+			}
+		}
+		this.seqObj = seqObj;
+		this.leadSurrogate = leadSurrogate;
+		return newBuf.slice(0, j);
+	};
+	DBCSEncoder.prototype.end = function() {
+		if (this.leadSurrogate === -1 && this.seqObj === void 0) return;
+		var newBuf = Buffer.alloc(10), j = 0;
+		if (this.seqObj) {
+			var dbcsCode = this.seqObj[DEF_CHAR];
+			if (dbcsCode !== void 0) {
+				if (dbcsCode < 256) newBuf[j++] = dbcsCode;
+				else {
+					newBuf[j++] = dbcsCode >> 8;
+					newBuf[j++] = dbcsCode & 255;
+				}
+			}
+			this.seqObj = void 0;
+		}
+		if (this.leadSurrogate !== -1) {
+			newBuf[j++] = this.defaultCharSingleByte;
+			this.leadSurrogate = -1;
+		}
+		return newBuf.slice(0, j);
+	};
+	DBCSEncoder.prototype.findIdx = findIdx;
+	function DBCSDecoder(options, codec) {
+		this.nodeIdx = 0;
+		this.prevBuf = Buffer.alloc(0);
+		this.decodeTables = codec.decodeTables;
+		this.decodeTableSeq = codec.decodeTableSeq;
+		this.defaultCharUnicode = codec.defaultCharUnicode;
+		this.gb18030 = codec.gb18030;
+	}
+	DBCSDecoder.prototype.write = function(buf) {
+		var newBuf = Buffer.alloc(buf.length * 2), nodeIdx = this.nodeIdx, prevBuf = this.prevBuf, prevBufOffset = this.prevBuf.length, seqStart = -this.prevBuf.length, uCode;
+		if (prevBufOffset > 0) prevBuf = Buffer.concat([prevBuf, buf.slice(0, 10)]);
+		for (var i = 0, j = 0; i < buf.length; i++) {
+			var curByte = i >= 0 ? buf[i] : prevBuf[i + prevBufOffset];
+			var uCode = this.decodeTables[nodeIdx][curByte];
+			if (uCode >= 0) {} else if (uCode === UNASSIGNED) {
+				i = seqStart;
+				uCode = this.defaultCharUnicode.charCodeAt(0);
+			} else if (uCode === GB18030_CODE) {
+				var curSeq = seqStart >= 0 ? buf.slice(seqStart, i + 1) : prevBuf.slice(seqStart + prevBufOffset, i + 1 + prevBufOffset);
+				var ptr = (curSeq[0] - 129) * 12600 + (curSeq[1] - 48) * 1260 + (curSeq[2] - 129) * 10 + (curSeq[3] - 48);
+				var idx = findIdx(this.gb18030.gbChars, ptr);
+				uCode = this.gb18030.uChars[idx] + ptr - this.gb18030.gbChars[idx];
+			} else if (uCode <= NODE_START) {
+				nodeIdx = NODE_START - uCode;
+				continue;
+			} else if (uCode <= SEQ_START) {
+				var seq = this.decodeTableSeq[SEQ_START - uCode];
+				for (var k = 0; k < seq.length - 1; k++) {
+					uCode = seq[k];
+					newBuf[j++] = uCode & 255;
+					newBuf[j++] = uCode >> 8;
+				}
+				uCode = seq[seq.length - 1];
+			} else throw new Error("iconv-lite internal error: invalid decoding table value " + uCode + " at " + nodeIdx + "/" + curByte);
+			if (uCode > 65535) {
+				uCode -= 65536;
+				var uCodeLead = 55296 + Math.floor(uCode / 1024);
+				newBuf[j++] = uCodeLead & 255;
+				newBuf[j++] = uCodeLead >> 8;
+				uCode = 56320 + uCode % 1024;
+			}
+			newBuf[j++] = uCode & 255;
+			newBuf[j++] = uCode >> 8;
+			nodeIdx = 0;
+			seqStart = i + 1;
+		}
+		this.nodeIdx = nodeIdx;
+		this.prevBuf = seqStart >= 0 ? buf.slice(seqStart) : prevBuf.slice(seqStart + prevBufOffset);
+		return newBuf.slice(0, j).toString("ucs2");
+	};
+	DBCSDecoder.prototype.end = function() {
+		var ret = "";
+		while (this.prevBuf.length > 0) {
+			ret += this.defaultCharUnicode;
+			var buf = this.prevBuf.slice(1);
+			this.prevBuf = Buffer.alloc(0);
+			this.nodeIdx = 0;
+			if (buf.length > 0) ret += this.write(buf);
+		}
+		this.nodeIdx = 0;
+		return ret;
+	};
+	function findIdx(table, val) {
+		if (table[0] > val) return -1;
+		var l = 0, r = table.length;
+		while (l < r - 1) {
+			var mid = l + Math.floor((r - l + 1) / 2);
+			if (table[mid] <= val) l = mid;
+			else r = mid;
+		}
+		return l;
+	}
+}));
+//#endregion
+export default require_dbcs_codec();
+export { require_dbcs_codec };

package/dist/deps/.pnpm/iconv-lite@0.4.24/deps/iconv-lite/encodings/dbcs-data.js

@@ -0,0 +1,123 @@
+import { __commonJSMin } from "../../../../../../_virtual/_rolldown/runtime.js";
+import { require_shiftjis } from "./tables/shiftjis.json.js";
+import { require_eucjp } from "./tables/eucjp.json.js";
+import { require_cp936 } from "./tables/cp936.json.js";
+import { require_gbk_added } from "./tables/gbk-added.json.js";
+import { require_gb18030_ranges } from "./tables/gb18030-ranges.json.js";
+import { require_cp949 } from "./tables/cp949.json.js";
+import { require_cp950 } from "./tables/cp950.json.js";
+import { require_big5_added } from "./tables/big5-added.json.js";
+//#region ../../node_modules/.pnpm/iconv-lite@0.4.24/node_modules/iconv-lite/encodings/dbcs-data.js
+var require_dbcs_data = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = {
+		"shiftjis": {
+			type: "_dbcs",
+			table: function() {
+				return require_shiftjis();
+			},
+			encodeAdd: {
+				"¥": 92,
+				"‾": 126
+			},
+			encodeSkipVals: [{
+				from: 60736,
+				to: 63808
+			}]
+		},
+		"csshiftjis": "shiftjis",
+		"mskanji": "shiftjis",
+		"sjis": "shiftjis",
+		"windows31j": "shiftjis",
+		"ms31j": "shiftjis",
+		"xsjis": "shiftjis",
+		"windows932": "shiftjis",
+		"ms932": "shiftjis",
+		"932": "shiftjis",
+		"cp932": "shiftjis",
+		"eucjp": {
+			type: "_dbcs",
+			table: function() {
+				return require_eucjp();
+			},
+			encodeAdd: {
+				"¥": 92,
+				"‾": 126
+			}
+		},
+		"gb2312": "cp936",
+		"gb231280": "cp936",
+		"gb23121980": "cp936",
+		"csgb2312": "cp936",
+		"csiso58gb231280": "cp936",
+		"euccn": "cp936",
+		"windows936": "cp936",
+		"ms936": "cp936",
+		"936": "cp936",
+		"cp936": {
+			type: "_dbcs",
+			table: function() {
+				return require_cp936();
+			}
+		},
+		"gbk": {
+			type: "_dbcs",
+			table: function() {
+				return require_cp936().concat(require_gbk_added());
+			}
+		},
+		"xgbk": "gbk",
+		"isoir58": "gbk",
+		"gb18030": {
+			type: "_dbcs",
+			table: function() {
+				return require_cp936().concat(require_gbk_added());
+			},
+			gb18030: function() {
+				return require_gb18030_ranges();
+			},
+			encodeSkipVals: [128],
+			encodeAdd: { "€": 41699 }
+		},
+		"chinese": "gb18030",
+		"windows949": "cp949",
+		"ms949": "cp949",
+		"949": "cp949",
+		"cp949": {
+			type: "_dbcs",
+			table: function() {
+				return require_cp949();
+			}
+		},
+		"cseuckr": "cp949",
+		"csksc56011987": "cp949",
+		"euckr": "cp949",
+		"isoir149": "cp949",
+		"korean": "cp949",
+		"ksc56011987": "cp949",
+		"ksc56011989": "cp949",
+		"ksc5601": "cp949",
+		"windows950": "cp950",
+		"ms950": "cp950",
+		"950": "cp950",
+		"cp950": {
+			type: "_dbcs",
+			table: function() {
+				return require_cp950();
+			}
+		},
+		"big5": "big5hkscs",
+		"big5hkscs": {
+			type: "_dbcs",
+			table: function() {
+				return require_cp950().concat(require_big5_added());
+			},
+			encodeSkipVals: [41676]
+		},
+		"cnbig5": "big5hkscs",
+		"csbig5": "big5hkscs",
+		"xxbig5": "big5hkscs"
+	};
+}));
+//#endregion
+export default require_dbcs_data();
+export { require_dbcs_data };