storm-lua-minify 0.3.0 → 0.9.0

package/dist/interproceduralConstants.js

@@ -0,0 +1,120 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.propagateInterproceduralConstants = propagateInterproceduralConstants;
+/**
+ * Replace a direct, pure, single-return call with its proven scalar result.
+ *
+ * This is intentionally narrower than #76 inlining. It accepts only a one-statement return body,
+ * no actual arguments, a non-recursive target, and a literal no longer than the shortest possible
+ * renamed `a()` call. Thus evaluation can be removed without alpha conversion and without relying
+ * on later function DCE to make the local rewrite profitable.
+ */
+function propagateInterproceduralConstants(chunk, analysis) {
+    let changed = false;
+    const replacementOf = (expression) => {
+        if (expression.type !== "CallExpression" ||
+            expression.arguments.length !== 0 ||
+            expression.base.type !== "Identifier")
+            return undefined;
+        const call = analysis.callGraph.callSiteOf(expression);
+        if (!call || call.hasUnknownTarget || call.targets.size !== 1)
+            return undefined;
+        const target = [...call.targets][0];
+        if (analysis.callGraph.sccs.some((scc) => scc.recursive && scc.functions.includes(target)) ||
+            target.declaration.body.length !== 1 ||
+            target.declaration.body[0].type !== "ReturnStatement")
+            return undefined;
+        const summary = analysis.summaryOf(target);
+        if (summary.effects.length > 0 ||
+            summary.escapes.length > 0 ||
+            summary.externalEffects.length > 0 ||
+            summary.mayError ||
+            summary.mayInvokeMetamethod ||
+            summary.returns.prefix.length !== 1 ||
+            summary.returns.tail.kind !== "none")
+            return undefined;
+        const value = summary.returns.prefix[0];
+        if (value.unknownReasons.length > 0 || value.atoms.length !== 1)
+            return undefined;
+        const replacement = literalOf(value.atoms[0], expression);
+        if (!replacement || printedLength(replacement) > 3)
+            return undefined;
+        return replacement;
+    };
+    const rewriteBlock = (body) => {
+        body.forEach((statement) => {
+            if ((statement.type === "LocalStatement" ||
+                statement.type === "AssignmentStatement") &&
+                statement.variables.length === 1 &&
+                statement.init.length === 1) {
+                const replacement = replacementOf(statement.init[0]);
+                if (replacement) {
+                    statement.init[0] = replacement;
+                    changed = true;
+                }
+            }
+            switch (statement.type) {
+                case "DoStatement":
+                case "WhileStatement":
+                case "RepeatStatement":
+                case "FunctionDeclaration":
+                case "ForNumericStatement":
+                case "ForGenericStatement":
+                    rewriteBlock(statement.body);
+                    return;
+                case "IfStatement":
+                    statement.clauses.forEach((clause) => {
+                        rewriteBlock(clause.body);
+                    });
+                    return;
+                default:
+                    return;
+            }
+        });
+    };
+    rewriteBlock(chunk.body);
+    return changed;
+}
+function literalOf(atom, source) {
+    const metadata = {
+        ...(source.loc ? { loc: source.loc } : {}),
+        ...("range" in source
+            ? { range: source.range }
+            : {}),
+    };
+    switch (atom.kind) {
+        case "nil":
+            return { type: "NilLiteral", value: null, raw: "nil", ...metadata };
+        case "boolean":
+            return {
+                type: "BooleanLiteral",
+                value: atom.value,
+                raw: atom.value ? "true" : "false",
+                ...metadata,
+            };
+        case "number":
+            return {
+                type: "NumericLiteral",
+                value: Number(atom.raw),
+                raw: atom.raw,
+                ...metadata,
+            };
+        case "string": {
+            const raw = JSON.stringify(atom.value);
+            return { type: "StringLiteral", value: atom.value, raw, ...metadata };
+        }
+        default:
+            return undefined;
+    }
+}
+function printedLength(expression) {
+    switch (expression.type) {
+        case "NilLiteral":
+        case "BooleanLiteral":
+        case "NumericLiteral":
+        case "StringLiteral":
+            return expression.raw.length;
+        default:
+            return Infinity;
+    }
+}

package/dist/luaString.js

@@ -0,0 +1,157 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.luaByteStringOfText = luaByteStringOfText;
+exports.decodeLuaStringLiteral = decodeLuaStringLiteral;
+exports.luaByteStringKey = luaByteStringKey;
+exports.compareLuaByteStrings = compareLuaByteStrings;
+exports.concatLuaByteStrings = concatLuaByteStrings;
+exports.encodeLuaByteString = encodeLuaByteString;
+const encoder = new TextEncoder();
+function luaByteStringOfText(text) {
+    return { bytes: encoder.encode(text) };
+}
+function decodeLuaStringLiteral(node) {
+    const raw = node.raw;
+    const long = /^\[(=*)\[/.exec(raw);
+    if (long) {
+        const close = `]${long[1]}]`;
+        if (!raw.endsWith(close)) {
+            return { ok: false, reason: "invalid-delimiter" };
+        }
+        let value = raw.slice(long[0].length, -close.length);
+        value = value.replace(/\r\n|\r/g, "\n");
+        if (value.startsWith("\n"))
+            value = value.slice(1);
+        return { ok: true, value: luaByteStringOfText(value) };
+    }
+    const quote = raw[0];
+    if (raw.length < 2 ||
+        (quote !== '"' && quote !== "'") ||
+        raw[raw.length - 1] !== quote) {
+        return { ok: false, reason: "invalid-delimiter" };
+    }
+    const bytes = [];
+    const appendText = (text) => bytes.push(...encoder.encode(text));
+    for (let index = 1; index < raw.length - 1; index++) {
+        const current = raw[index];
+        if (current !== "\\") {
+            const codePoint = raw.codePointAt(index);
+            if (codePoint === undefined) {
+                return { ok: false, reason: "invalid-code-point" };
+            }
+            appendText(String.fromCodePoint(codePoint));
+            if (codePoint > 0xffff)
+                index++;
+            continue;
+        }
+        index++;
+        if (index >= raw.length - 1) {
+            return { ok: false, reason: "invalid-escape" };
+        }
+        const escaped = raw[index];
+        const simple = SIMPLE_ESCAPES[escaped];
+        if (simple !== undefined) {
+            bytes.push(simple);
+            continue;
+        }
+        if (escaped === "\n" || escaped === "\r") {
+            if (escaped === "\r" && raw[index + 1] === "\n")
+                index++;
+            bytes.push(0x0a);
+            continue;
+        }
+        if (escaped === "z") {
+            while (/\s/.test(raw[index + 1] ?? ""))
+                index++;
+            continue;
+        }
+        if (escaped === "x") {
+            const hex = raw.slice(index + 1, index + 3);
+            if (!/^[0-9a-fA-F]{2}$/.test(hex)) {
+                return { ok: false, reason: "invalid-escape" };
+            }
+            bytes.push(Number.parseInt(hex, 16));
+            index += 2;
+            continue;
+        }
+        if (escaped === "u") {
+            const match = /^\{([0-9a-fA-F]+)\}/.exec(raw.slice(index + 1));
+            if (!match)
+                return { ok: false, reason: "invalid-escape" };
+            const codePoint = Number.parseInt(match[1], 16);
+            if (codePoint > 0x10ffff ||
+                (codePoint >= 0xd800 && codePoint <= 0xdfff)) {
+                return { ok: false, reason: "invalid-code-point" };
+            }
+            appendText(String.fromCodePoint(codePoint));
+            index += match[0].length;
+            continue;
+        }
+        if (/\d/.test(escaped)) {
+            let digits = escaped;
+            while (digits.length < 3 && /\d/.test(raw[index + 1] ?? "")) {
+                digits += raw[++index];
+            }
+            const byte = Number.parseInt(digits, 10);
+            if (byte > 255)
+                return { ok: false, reason: "out-of-range-byte" };
+            bytes.push(byte);
+            continue;
+        }
+        return { ok: false, reason: "invalid-escape" };
+    }
+    return { ok: true, value: { bytes: Uint8Array.from(bytes) } };
+}
+function luaByteStringKey(value) {
+    return Array.from(value.bytes, (byte) => byte.toString(16).padStart(2, "0")).join("");
+}
+function compareLuaByteStrings(left, right) {
+    const length = Math.min(left.bytes.length, right.bytes.length);
+    for (let index = 0; index < length; index++) {
+        if (left.bytes[index] !== right.bytes[index]) {
+            return left.bytes[index] - right.bytes[index];
+        }
+    }
+    return left.bytes.length - right.bytes.length;
+}
+function concatLuaByteStrings(left, right) {
+    const bytes = new Uint8Array(left.bytes.length + right.bytes.length);
+    bytes.set(left.bytes);
+    bytes.set(right.bytes, left.bytes.length);
+    return { bytes };
+}
+/** 任意のLua byte列を、再decode可能な決定論的quoted literalへ戻す。 */
+function encodeLuaByteString(value) {
+    const encodeWith = (quote) => {
+        let raw = String.fromCharCode(quote);
+        value.bytes.forEach((byte) => {
+            if (byte === quote || byte === 0x5c) {
+                raw += `\\${String.fromCharCode(byte)}`;
+            }
+            else if (byte >= 0x20 && byte <= 0x7e) {
+                raw += String.fromCharCode(byte);
+            }
+            else {
+                raw += `\\x${byte.toString(16).padStart(2, "0")}`;
+            }
+        });
+        return raw + String.fromCharCode(quote);
+    };
+    const doubleQuoted = encodeWith(0x22);
+    const singleQuoted = encodeWith(0x27);
+    return singleQuoted.length < doubleQuoted.length
+        ? singleQuoted
+        : doubleQuoted;
+}
+const SIMPLE_ESCAPES = {
+    a: 0x07,
+    b: 0x08,
+    f: 0x0c,
+    n: 0x0a,
+    r: 0x0d,
+    t: 0x09,
+    v: 0x0b,
+    "\\": 0x5c,
+    '"': 0x22,
+    "'": 0x27,
+};