@rohal12/twee-ts 1.18.1 → 1.18.2

package/dist/bin/twee-ts.js

@@ -1,6 +1,6 @@
 #!/usr/bin/env node
 import { parseArgs } from "node:util";
-import { accessSync, chmodSync, constants, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, realpathSync, renameSync, rmSync, statSync, watch, writeFileSync } from "node:fs";
+import { accessSync, chmodSync, constants, existsSync, lstatSync, mkdirSync, readFileSync, readdirSync, readlinkSync, realpathSync, renameSync, rmSync, statSync, watch, writeFileSync } from "node:fs";
 import * as nodePath from "node:path";
 import { basename, dirname, extname, isAbsolute, join, parse, relative, resolve, sep } from "node:path";
 import { createHash, randomBytes, randomUUID } from "node:crypto";
@@ -1555,6 +1555,89 @@ function stripSetupFunction(chunk) {
 	for (const match of chunk.matchAll(SETUP_FUNCTION_PROPERTY)) lastIndex = match.index;
 	return lastIndex === -1 ? void 0 : chunk.slice(0, lastIndex) + "}";
 }
+/** Index after the whitespace and `//` or block comments starting at `i`. */
+function skipTrivia(text, i) {
+	let pos = i;
+	for (;;) {
+		const ch = text[pos];
+		if (ch !== void 0 && /\s/.test(ch)) pos++;
+		else if (text.startsWith("//", pos)) {
+			const newline = text.indexOf("\n", pos);
+			pos = newline === -1 ? text.length : newline + 1;
+		} else if (text.startsWith("/*", pos)) {
+			const close = text.indexOf("*/", pos + 2);
+			pos = close === -1 ? text.length : close + 2;
+		} else return pos;
+	}
+}
+/** Index after the quoted string starting at `i` (a quote character); template literals nest `${…}`. */
+function skipString(text, i) {
+	const quote = text[i];
+	let pos = i + 1;
+	while (pos < text.length) {
+		const ch = text[pos];
+		if (ch === "\\") pos += 2;
+		else if (ch === quote) return pos + 1;
+		else if (quote === "`" && ch === "$" && text[pos + 1] === "{") {
+			const close = findClosingBrace(text, pos + 1);
+			if (close === -1) return text.length;
+			pos = close + 1;
+		} else pos++;
+	}
+	return text.length;
+}
+function startsComment(text, pos) {
+	return text[pos] === "/" && (text[pos + 1] === "/" || text[pos + 1] === "*");
+}
+function startsString(text, pos) {
+	const ch = text[pos];
+	return ch === "\"" || ch === "'" || ch === "`";
+}
+/** Index of the `}` matching the `{` at `open`, skipping comments and strings; -1 when unbalanced. */
+function findClosingBrace(text, open) {
+	let depth = 0;
+	let pos = open;
+	while (pos < text.length) if (startsComment(text, pos)) pos = skipTrivia(text, pos);
+	else if (startsString(text, pos)) pos = skipString(text, pos);
+	else {
+		if (text[pos] === "{") depth++;
+		else if (text[pos] === "}" && --depth === 0) return pos;
+		pos++;
+	}
+	return -1;
+}
+const STORY_FORMAT = "storyFormat";
+const IDENTIFIER_CHAR = /[\w$]/;
+/**
+* Locate the object literal passed to `storyFormat(` as `[start, end)` offsets, ignoring comments and
+* strings outside it and never evaluating anything. Without such a call, the first `{` outside comments
+* and strings starts the object. When its closing brace cannot be matched (a Harlowe setup function can
+* hold regular expression literals), the last `}` of the file ends it.
+*/
+function locateFormatObject(text) {
+	let start = -1;
+	let firstBrace = -1;
+	let pos = 0;
+	while (pos < text.length && start === -1) if (startsComment(text, pos)) pos = skipTrivia(text, pos);
+	else if (startsString(text, pos)) pos = skipString(text, pos);
+	else if (text[pos] === "{") {
+		if (firstBrace === -1) firstBrace = pos;
+		pos++;
+	} else if (text.startsWith(STORY_FORMAT, pos) && !IDENTIFIER_CHAR.test(text[pos - 1] ?? "")) {
+		const paren = skipTrivia(text, pos + 11);
+		const brace = text[paren] === "(" ? skipTrivia(text, paren + 1) : -1;
+		if (text[brace] === "{") start = brace;
+		pos += 11;
+	} else pos++;
+	if (start === -1) start = firstBrace;
+	if (start === -1) return void 0;
+	const close = findClosingBrace(text, start);
+	const end = close === -1 ? text.lastIndexOf("}") : close;
+	return end < start ? void 0 : {
+		start,
+		end: end + 1
+	};
+}
 /**
 * Parse the format object at `start`–`end` of `text`: strict JSON first (fast), then the
 * JavaScript literal subset formats use. Error positions point into `text`.
@@ -1625,15 +1708,14 @@ function toFormatJSON(raw) {
 * `harlowe-3` directory or a direct download.
 */
 function decodeFormatJSON(source) {
-	const first = source.indexOf("{");
-	const last = source.lastIndexOf("}");
-	if (first === -1 || last < first) return {
+	const located = locateFormatObject(source);
+	if (located === void 0) return {
 		ok: false,
 		reason: "Could not find Twine 2 style story format JSON chunk."
 	};
-	const parsed = parseFormatObject(source, first, last + 1);
+	const parsed = parseFormatObject(source, located.start, located.end);
 	if (parsed.ok) return toFormatJSON(parsed.value);
-	const stripped = stripSetupFunction(source.slice(first, last + 1));
+	const stripped = stripSetupFunction(source.slice(located.start, located.end));
 	const retried = stripped === void 0 ? void 0 : parseFormatObject(stripped, 0, stripped.length);
 	if (retried?.ok) return toFormatJSON(retried.value);
 	return {
@@ -1920,16 +2002,17 @@ function readFormatSource(format, diagnostics) {
 /**
 * Writes `data` to `path` so that a reader sees either the previous file or the complete new
 * one, never a partly written file. The data goes to a temporary file in the same folder,
-* which is then renamed over `path`. When `path` is a symlink, the file it points to is
-* replaced, and an existing file keeps its permissions.
+* which is then renamed over `path`. When `path` is a symlink (even a dangling one, or a chain of links), the file it
+* finally points to is replaced or created and the link stays, and an existing file keeps its permissions.
 *
 * On failure (a full disk, a missing folder) the temporary file is removed, `path` is left
 * as it was, and the error is thrown with `path` in its message and its original `code`.
 */
 function writeFileAtomic(path, data) {
-	const target = followSymlink(path);
-	const temp = join(dirname(target), `.${basename(target)}.${process.pid}-${randomBytes(6).toString("hex")}.tmp`);
+	let temp;
 	try {
+		const target = resolveWriteTarget(path);
+		temp = join(dirname(target), `.${basename(target)}.${process.pid}-${randomBytes(6).toString("hex")}.tmp`);
 		writeFileSync(temp, data, {
 			encoding: "utf-8",
 			flag: "wx"
@@ -1937,17 +2020,25 @@ function writeFileAtomic(path, data) {
 		keepPermissions(target, temp);
 		renameSync(temp, target);
 	} catch (e) {
-		rmSync(temp, { force: true });
+		if (temp !== void 0) rmSync(temp, { force: true });
 		throw writeError(path, e);
 	}
 }
-/** The file a symlink at `path` points to, or `path` itself (also when it doesn't exist yet). */
-function followSymlink(path) {
-	try {
-		return realpathSync(path);
-	} catch {
-		return path;
+/** Links followed before a path counts as a cycle (Linux stops at 40 as well). */
+const MAX_LINK_DEPTH = 40;
+/**
+* The file a symlink at `path` finally points to, or `path` itself when it is no link. Links are
+* followed one by one, so a link whose target does not exist yet (absolute, relative, or a chain
+* of them) still resolves to the file that should be created. A cycle or an unreadable link throws.
+*/
+function resolveWriteTarget(path) {
+	let current = path;
+	for (let depth = 0; depth <= MAX_LINK_DEPTH; depth++) {
+		const stat = lstatSync(current, { throwIfNoEntry: false });
+		if (stat === void 0 || !stat.isSymbolicLink()) return current;
+		current = resolve(dirname(current), readlinkSync(current));
 	}
+	throw Object.assign(/* @__PURE__ */ new Error(`ELOOP: too many levels of symbolic links, ${path}`), { code: "ELOOP" });
 }
 /**
 * Gives `temp` the permission bits of `target`, when `target` exists. Best effort: on a file
@@ -2289,6 +2380,16 @@ async function resolveFormatUrls(request, urls, options = {}) {
 	}
 	if (lastError) throw lastError;
 }
+/**
+* Find the best format among the cached copies of direct format URLs, without network access.
+* Matching follows {@link selectFormatCandidate}, so `allowOlder` admits a same-major older version.
+* Each URL keeps its own copy; the shared name and version downloads are never consulted.
+*
+* Internal, for format resolution; not part of the public API.
+*/
+function findCachedUrlFormat(request, urls, options = {}) {
+	return selectFormatCandidate(request, urls.flatMap((url) => getCachedDirectFormat(url) ?? []), (f) => f, options);
+}
 /** Whether `info` is a format the request accepts. */
 function answers(request, info) {
 	return selectFormatCandidate(request, [info], (f) => f) !== void 0;
@@ -2524,8 +2625,8 @@ function findLocalFormat(all, pruned, request) {
 * then format indices (unless `noRemote`). Names and IDs match the same way in each (see
 * `selectFormatCandidate`), so a request that a local format answers never reaches the cache or the
 * network. Local formats that cannot be used are reported as warnings. When a StoryData request
-* names a version that none of them has, an older version of
-* the same format and major version is used with a warning. Anything else is an error diagnostic,
+* names a version that none of them has, an older version of the same format and major version
+* is used with a warning, from local formats, the project's cached format URLs, or the shared cache. Anything else is an error diagnostic,
 * and the result is `undefined`.
 */
 async function resolveStoryFormat(request, options, diagnostics) {
@@ -2563,7 +2664,7 @@ async function resolveStoryFormat(request, options, diagnostics) {
 		if (remote) return remote;
 	}
 	if (request.kind === "name") {
-		const older = selectFormatCandidate(request, rankedTwine2Formats(pruned), (f) => f, { allowOlder: true }) ?? findCachedFormat(request, { allowOlder: true });
+		const older = selectFormatCandidate(request, rankedTwine2Formats(pruned), (f) => f, { allowOlder: true }) ?? findCachedUrlFormat(request, options.formatUrls ?? [], { allowOlder: true }) ?? findCachedFormat(request, { allowOlder: true });
 		if (older) {
 			diagnostics.push({
 				level: "warning",
@@ -6411,8 +6512,16 @@ const isLetter = (c) => c !== void 0 && /^[A-Za-z]$/.test(c);
 * a full HTML tokenizer; it needs no more than the tags and where they end.
 */
 function scanHeadTags(html) {
+	const { closingHead, bodyStart } = scanTags$1(html);
+	return {
+		closingHead,
+		bodyStart
+	};
+}
+function scanTags$1(html) {
 	let closingHead;
 	let bodyStart;
+	let headStartEnd;
 	let i = 0;
 	while (i < html.length) {
 		const lt = html.indexOf("<", i);
@@ -6431,13 +6540,15 @@ function scanHeadTags(html) {
 		} else if (isLetter(next)) {
 			const { name, end } = readTag(html, lt + 1);
 			if (name === "body" && bodyStart === void 0) bodyStart = lt;
+			if (name === "head" && headStartEnd === void 0) headStartEnd = end;
 			i = RAW_TEXT_ELEMENTS.has(name) ? rawTextEnd(html, name, end) : end;
 		} else i = lt + 1;
 		if (closingHead !== void 0 && bodyStart !== void 0) break;
 	}
 	return {
 		closingHead,
-		bodyStart
+		bodyStart,
+		headStartEnd
 	};
 }
 /** Read a tag whose name starts at `from`: its lowercase name, and the offset after its `>` (or the end). */