typescript-to-lua 1.11.1 → 1.12.1

package/dist/transformation/visitors/expression-statement.d.ts

@@ -1,5 +1,5 @@
 import * as ts from "typescript";
 import * as lua from "../../LuaAST";
-import { FunctionVisitor, TransformationContext } from "../context";
+import { FunctionVisitor } from "../context";
 export declare const transformExpressionStatement: FunctionVisitor<ts.ExpressionStatement>;
-export declare function transformExpressionToStatement(context: TransformationContext, expression: ts.Expression): lua.Statement | undefined;
+export declare function wrapInStatement(result: lua.Expression): lua.Statement | undefined;

package/dist/transformation/visitors/expression-statement.js

@@ -1,6 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.transformExpressionToStatement = exports.transformExpressionStatement = void 0;
+exports.wrapInStatement = exports.transformExpressionStatement = void 0;
 const lua = require("../../LuaAST");
 const context_1 = require("../context");
 const binary_expression_1 = require("./binary-expression");
@@ -14,11 +14,10 @@ const transformExpressionStatement = (node, context) => {
     if (binaryExpressionResult) {
         return binaryExpressionResult;
     }
-    return transformExpressionToStatement(context, node.expression);
+    return wrapInStatement(context.transformExpression(node.expression));
 };
 exports.transformExpressionStatement = transformExpressionStatement;
-function transformExpressionToStatement(context, expression) {
-    const result = context.transformExpression(expression);
+function wrapInStatement(result) {
     const isTempVariable = lua.isIdentifier(result) && result.symbolId === context_1.tempSymbolId;
     if (isTempVariable) {
         return undefined;
@@ -34,5 +33,5 @@ function transformExpressionToStatement(context, expression) {
     // Assign expression statements to dummy to make sure they're legal Lua
     return lua.createVariableDeclarationStatement(lua.createAnonymousIdentifier(), result);
 }
-exports.transformExpressionToStatement = transformExpressionToStatement;
+exports.wrapInStatement = wrapInStatement;
 //# sourceMappingURL=expression-statement.js.map

package/dist/transformation/visitors/identifier.js

@@ -21,7 +21,9 @@ function transformIdentifier(context, identifier) {
 exports.transformIdentifier = transformIdentifier;
 function transformNonValueIdentifier(context, identifier, symbol) {
     if ((0, optional_chaining_1.isOptionalContinuation)(identifier)) {
-        return lua.createIdentifier(identifier.text, undefined, context_1.tempSymbolId);
+        const result = lua.createIdentifier(identifier.text, undefined, context_1.tempSymbolId);
+        (0, optional_chaining_1.getOptionalContinuationData)(identifier).usedIdentifiers.push(result);
+        return result;
     }
     const extensionKind = symbol
         ? (0, language_extensions_1.getExtensionKindForSymbol)(context, symbol)

package/dist/transformation/visitors/language-extensions/operators.js

@@ -1,12 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.operatorExtensionTransformers = void 0;
-const ts = require("typescript");
 const lua = require("../../../LuaAST");
 const utils_1 = require("../../../utils");
 const CompilerOptions_1 = require("../../../CompilerOptions");
 const diagnostics_1 = require("../../utils/diagnostics");
 const language_extensions_1 = require("../../utils/language-extensions");
+const expression_list_1 = require("../expression-list");
 const binaryOperatorMappings = new Map([
     [language_extensions_1.ExtensionKind.AdditionOperatorType, lua.SyntaxKind.AdditionOperator],
     [language_extensions_1.ExtensionKind.AdditionOperatorMethodType, lua.SyntaxKind.AdditionOperator],
@@ -76,26 +76,20 @@ for (const kind of unaryOperatorMappings.keys()) {
 function transformBinaryOperator(context, node, kind) {
     if (requiresLua53.has(kind))
         checkHasLua53(context, node, kind);
-    let args = node.arguments;
-    if (args.length === 1 &&
-        (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression))) {
-        args = [node.expression.expression, ...args];
-    }
+    const args = (0, language_extensions_1.getBinaryCallExtensionArgs)(context, node, kind);
+    if (!args)
+        return lua.createNilLiteral();
+    const [left, right] = (0, expression_list_1.transformOrderedExpressions)(context, args);
     const luaOperator = binaryOperatorMappings.get(kind);
     (0, utils_1.assert)(luaOperator);
-    return lua.createBinaryExpression(context.transformExpression(args[0]), context.transformExpression(args[1]), luaOperator);
+    return lua.createBinaryExpression(left, right, luaOperator);
 }
 function transformUnaryOperator(context, node, kind) {
     if (requiresLua53.has(kind))
         checkHasLua53(context, node, kind);
-    let arg;
-    if (node.arguments.length === 0 &&
-        (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression))) {
-        arg = node.expression.expression;
-    }
-    else {
-        arg = node.arguments[0];
-    }
+    const arg = (0, language_extensions_1.getUnaryCallExtensionArg)(context, node, kind);
+    if (!arg)
+        return lua.createNilLiteral();
     const luaOperator = unaryOperatorMappings.get(kind);
     (0, utils_1.assert)(luaOperator);
     return lua.createUnaryExpression(context.transformExpression(arg), luaOperator);

package/dist/transformation/visitors/language-extensions/table.d.ts

@@ -1,9 +1,7 @@
 import * as ts from "typescript";
 import { TransformationContext } from "../../context";
 import { ExtensionKind } from "../../utils/language-extensions";
-import { LanguageExtensionCallTransformer } from "./call-extension";
+import { LanguageExtensionCallTransformerMap } from "./call-extension";
 export declare function isTableNewCall(context: TransformationContext, node: ts.NewExpression): boolean;
 export declare const tableNewExtensions: ExtensionKind[];
-export declare const tableExtensionTransformers: {
-    [P in ExtensionKind]?: LanguageExtensionCallTransformer;
-};
+export declare const tableExtensionTransformers: LanguageExtensionCallTransformerMap;

package/dist/transformation/visitors/language-extensions/table.js

@@ -1,7 +1,6 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.tableExtensionTransformers = exports.tableNewExtensions = exports.isTableNewCall = void 0;
-const ts = require("typescript");
 const lua = require("../../../LuaAST");
 const language_extensions_1 = require("../../utils/language-extensions");
 const expression_list_1 = require("../expression-list");
@@ -19,62 +18,57 @@ exports.tableExtensionTransformers = {
     [language_extensions_1.ExtensionKind.TableHasMethodType]: transformTableHasExpression,
     [language_extensions_1.ExtensionKind.TableSetType]: transformTableSetExpression,
     [language_extensions_1.ExtensionKind.TableSetMethodType]: transformTableSetExpression,
-    [language_extensions_1.ExtensionKind.TableAddKeyType]: transformTableAddExpression,
-    [language_extensions_1.ExtensionKind.TableAddKeyMethodType]: transformTableAddExpression,
+    [language_extensions_1.ExtensionKind.TableAddKeyType]: transformTableAddKeyExpression,
+    [language_extensions_1.ExtensionKind.TableAddKeyMethodType]: transformTableAddKeyExpression,
 };
 function transformTableDeleteExpression(context, node, extensionKind) {
-    const args = node.arguments.slice();
-    if (extensionKind === language_extensions_1.ExtensionKind.TableDeleteMethodType &&
-        (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression))) {
-        // In case of method (no table argument), push method owner to front of args list
-        args.unshift(node.expression.expression);
+    const args = (0, language_extensions_1.getBinaryCallExtensionArgs)(context, node, extensionKind);
+    if (!args) {
+        return lua.createNilLiteral();
     }
-    const [table, accessExpression] = (0, expression_list_1.transformExpressionList)(context, args);
+    const [table, key] = (0, expression_list_1.transformOrderedExpressions)(context, args);
     // arg0[arg1] = nil
-    context.addPrecedingStatements(lua.createAssignmentStatement(lua.createTableIndexExpression(table, accessExpression), lua.createNilLiteral(), node));
+    context.addPrecedingStatements(lua.createAssignmentStatement(lua.createTableIndexExpression(table, key), lua.createNilLiteral(), node));
     return lua.createBooleanLiteral(true);
 }
-function transformWithTableArgument(context, node) {
-    if (ts.isPropertyAccessExpression(node.expression) || ts.isElementAccessExpression(node.expression)) {
-        return (0, expression_list_1.transformExpressionList)(context, [node.expression.expression, ...node.arguments]);
-    }
-    // todo: report diagnostic?
-    return [lua.createNilLiteral(), ...(0, expression_list_1.transformExpressionList)(context, node.arguments)];
-}
 function transformTableGetExpression(context, node, extensionKind) {
-    const args = extensionKind === language_extensions_1.ExtensionKind.TableGetMethodType
-        ? transformWithTableArgument(context, node)
-        : (0, expression_list_1.transformExpressionList)(context, node.arguments);
-    const [table, accessExpression] = args;
+    const args = (0, language_extensions_1.getBinaryCallExtensionArgs)(context, node, extensionKind);
+    if (!args) {
+        return lua.createNilLiteral();
+    }
+    const [table, key] = (0, expression_list_1.transformOrderedExpressions)(context, args);
     // arg0[arg1]
-    return lua.createTableIndexExpression(table, accessExpression, node);
+    return lua.createTableIndexExpression(table, key, node);
 }
 function transformTableHasExpression(context, node, extensionKind) {
-    const args = extensionKind === language_extensions_1.ExtensionKind.TableHasMethodType
-        ? transformWithTableArgument(context, node)
-        : (0, expression_list_1.transformExpressionList)(context, node.arguments);
-    const [table, accessExpression] = args;
+    const args = (0, language_extensions_1.getBinaryCallExtensionArgs)(context, node, extensionKind);
+    if (!args) {
+        return lua.createNilLiteral();
+    }
+    const [table, key] = (0, expression_list_1.transformOrderedExpressions)(context, args);
     // arg0[arg1]
-    const tableIndexExpression = lua.createTableIndexExpression(table, accessExpression);
+    const tableIndexExpression = lua.createTableIndexExpression(table, key);
     // arg0[arg1] ~= nil
     return lua.createBinaryExpression(tableIndexExpression, lua.createNilLiteral(), lua.SyntaxKind.InequalityOperator, node);
 }
 function transformTableSetExpression(context, node, extensionKind) {
-    const args = extensionKind === language_extensions_1.ExtensionKind.TableSetMethodType
-        ? transformWithTableArgument(context, node)
-        : (0, expression_list_1.transformExpressionList)(context, node.arguments);
-    const [table, accessExpression, value] = args;
+    const args = (0, language_extensions_1.getNaryCallExtensionArgs)(context, node, extensionKind, 3);
+    if (!args) {
+        return lua.createNilLiteral();
+    }
+    const [table, key, value] = (0, expression_list_1.transformOrderedExpressions)(context, args);
     // arg0[arg1] = arg2
-    context.addPrecedingStatements(lua.createAssignmentStatement(lua.createTableIndexExpression(table, accessExpression), value, node));
+    context.addPrecedingStatements(lua.createAssignmentStatement(lua.createTableIndexExpression(table, key), value, node));
     return lua.createNilLiteral();
 }
-function transformTableAddExpression(context, node, extensionKind) {
-    const args = extensionKind === language_extensions_1.ExtensionKind.TableAddKeyMethodType
-        ? transformWithTableArgument(context, node)
-        : (0, expression_list_1.transformExpressionList)(context, node.arguments);
-    const [table, value] = args;
+function transformTableAddKeyExpression(context, node, extensionKind) {
+    const args = (0, language_extensions_1.getNaryCallExtensionArgs)(context, node, extensionKind, 2);
+    if (!args) {
+        return lua.createNilLiteral();
+    }
+    const [table, key] = (0, expression_list_1.transformOrderedExpressions)(context, args);
     // arg0[arg1] = true
-    context.addPrecedingStatements(lua.createAssignmentStatement(lua.createTableIndexExpression(table, value), lua.createBooleanLiteral(true), node));
+    context.addPrecedingStatements(lua.createAssignmentStatement(lua.createTableIndexExpression(table, key), lua.createBooleanLiteral(true), node));
     return lua.createNilLiteral();
 }
 //# sourceMappingURL=table.js.map

package/dist/transformation/visitors/optional-chaining.d.ts

@@ -8,9 +8,10 @@ export interface ExpressionWithThisValue {
 export declare function captureThisValue(context: TransformationContext, expression: lua.Expression, thisValueCapture: lua.Identifier, tsOriginal: ts.Node): lua.Expression;
 export interface OptionalContinuation {
     contextualCall?: lua.CallExpression;
+    usedIdentifiers: lua.Identifier[];
 }
 export declare function isOptionalContinuation(node: ts.Node): boolean;
 export declare function getOptionalContinuationData(identifier: ts.Identifier): OptionalContinuation | undefined;
 export declare function transformOptionalChain(context: TransformationContext, node: ts.OptionalChain): lua.Expression;
-export declare function transformOptionalChainWithCapture(context: TransformationContext, node: ts.OptionalChain, thisValueCapture: lua.Identifier | undefined, isDelete?: ts.DeleteExpression): ExpressionWithThisValue;
+export declare function transformOptionalChainWithCapture(context: TransformationContext, tsNode: ts.OptionalChain, thisValueCapture: lua.Identifier | undefined, isDelete?: ts.DeleteExpression): ExpressionWithThisValue;
 export declare function transformOptionalDeleteExpression(context: TransformationContext, node: ts.DeleteExpression, innerExpression: ts.OptionalChain): lua.BooleanLiteral;

package/dist/transformation/visitors/optional-chaining.js

@@ -8,6 +8,8 @@ const utils_1 = require("../../utils");
 const preceding_statements_1 = require("../utils/preceding-statements");
 const access_1 = require("./access");
 const expression_list_1 = require("./expression-list");
+const typescript_1 = require("../utils/typescript");
+const expression_statement_1 = require("./expression-statement");
 function skipNonNullChains(chain) {
     while (ts.isNonNullChain(chain)) {
         chain = chain.expression;
@@ -39,7 +41,7 @@ function transformExpressionWithThisValueCapture(context, node, thisValueCapture
 }
 // returns thisValueCapture exactly if a temp variable was used.
 function captureThisValue(context, expression, thisValueCapture, tsOriginal) {
-    if (!(0, expression_list_1.shouldMoveToTemp)(context, expression, tsOriginal) && !isOptionalContinuation(tsOriginal)) {
+    if (!(0, expression_list_1.shouldMoveToTemp)(context, expression, tsOriginal)) {
         return expression;
     }
     const tempAssignment = lua.createAssignmentStatement(thisValueCapture, expression, tsOriginal);
@@ -52,7 +54,9 @@ const optionalContinuations = new WeakMap();
 function createOptionalContinuationIdentifier(text, tsOriginal) {
     const identifier = ts.factory.createIdentifier(text);
     ts.setOriginalNode(identifier, tsOriginal);
-    optionalContinuations.set(identifier, {});
+    optionalContinuations.set(identifier, {
+        usedIdentifiers: [],
+    });
     return identifier;
 }
 function isOptionalContinuation(node) {
@@ -67,12 +71,11 @@ function transformOptionalChain(context, node) {
     return transformOptionalChainWithCapture(context, node, undefined).expression;
 }
 exports.transformOptionalChain = transformOptionalChain;
-function transformOptionalChainWithCapture(context, node, thisValueCapture, isDelete) {
-    var _a;
-    const luaTemp = context.createTempNameForNode(node);
-    const { expression: tsLeftExpression, chain } = flattenChain(node);
+function transformOptionalChainWithCapture(context, tsNode, thisValueCapture, isDelete) {
+    const luaTempName = context.createTempName("opt");
+    const { expression: tsLeftExpression, chain } = flattenChain(tsNode);
     // build temp.b.c.d
-    const tsTemp = createOptionalContinuationIdentifier(luaTemp.text, tsLeftExpression);
+    const tsTemp = createOptionalContinuationIdentifier(luaTempName, tsLeftExpression);
     let tsRightExpression = tsTemp;
     for (const link of chain) {
         if (ts.isPropertyAccessExpression(link)) {
@@ -96,21 +99,20 @@ function transformOptionalChainWithCapture(context, node, thisValueCapture, isDe
     // transform right expression first to check if thisValue capture is needed
     // capture and return thisValue if requested from outside
     let returnThisValue;
-    const [rightPrecedingStatements, rightAssignment] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => {
-        let result;
-        if (thisValueCapture) {
-            ({ expression: result, thisValue: returnThisValue } = transformExpressionWithThisValueCapture(context, tsRightExpression, thisValueCapture));
-        }
-        else {
-            result = context.transformExpression(tsRightExpression);
+    const [rightPrecedingStatements, rightExpression] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => {
+        if (!thisValueCapture) {
+            return context.transformExpression(tsRightExpression);
         }
-        return lua.createAssignmentStatement(luaTemp, result);
+        const { expression: result, thisValue } = transformExpressionWithThisValueCapture(context, tsRightExpression, thisValueCapture);
+        returnThisValue = thisValue;
+        return result;
     });
     // transform left expression, handle thisValue if needed by rightExpression
     const thisValueCaptureName = context.createTempName("this");
     const leftThisValueTemp = lua.createIdentifier(thisValueCaptureName, undefined, context_1.tempSymbolId);
     let capturedThisValue;
-    const rightContextualCall = (_a = getOptionalContinuationData(tsTemp)) === null || _a === void 0 ? void 0 : _a.contextualCall;
+    const optionalContinuationData = getOptionalContinuationData(tsTemp);
+    const rightContextualCall = optionalContinuationData === null || optionalContinuationData === void 0 ? void 0 : optionalContinuationData.contextualCall;
     const [leftPrecedingStatements, leftExpression] = (0, preceding_statements_1.transformInPrecedingStatementScope)(context, () => {
         let result;
         if (rightContextualCall) {
@@ -146,22 +148,66 @@ function transformOptionalChainWithCapture(context, node, thisValueCapture, isDe
             }
         }
     }
-    // <left preceding statements>
-    // local temp = <left>
-    // if temp ~= nil then
-    //   <right preceding statements>
-    //   temp = temp.b.c.d
-    // end
-    // return temp
-    context.addPrecedingStatements([
-        ...leftPrecedingStatements,
-        lua.createVariableDeclarationStatement(luaTemp, leftExpression),
-        lua.createIfStatement(lua.createBinaryExpression(luaTemp, lua.createNilLiteral(), lua.SyntaxKind.InequalityOperator), lua.createBlock([...rightPrecedingStatements, rightAssignment])),
-    ]);
-    return {
-        expression: luaTemp,
-        thisValue: returnThisValue,
-    };
+    // evaluate optional chain
+    context.addPrecedingStatements(leftPrecedingStatements);
+    // try use existing variable instead of creating new one, if possible
+    let leftIdentifier;
+    const usedLuaIdentifiers = optionalContinuationData === null || optionalContinuationData === void 0 ? void 0 : optionalContinuationData.usedIdentifiers;
+    const reuseLeftIdentifier = usedLuaIdentifiers &&
+        usedLuaIdentifiers.length > 0 &&
+        lua.isIdentifier(leftExpression) &&
+        (rightPrecedingStatements.length === 0 || !(0, expression_list_1.shouldMoveToTemp)(context, leftExpression, tsLeftExpression));
+    if (reuseLeftIdentifier) {
+        leftIdentifier = leftExpression;
+        for (const usedIdentifier of usedLuaIdentifiers) {
+            usedIdentifier.text = leftIdentifier.text;
+        }
+    }
+    else {
+        leftIdentifier = lua.createIdentifier(luaTempName, undefined, context_1.tempSymbolId);
+        context.addPrecedingStatements(lua.createVariableDeclarationStatement(leftIdentifier, leftExpression));
+    }
+    if (!(0, typescript_1.expressionResultIsUsed)(tsNode) || isDelete) {
+        // if left ~= nil then
+        //   <right preceding statements>
+        //   <right expression>
+        // end
+        const innerExpression = (0, expression_statement_1.wrapInStatement)(rightExpression);
+        const innerStatements = rightPrecedingStatements;
+        if (innerExpression)
+            innerStatements.push(innerExpression);
+        context.addPrecedingStatements(lua.createIfStatement(lua.createBinaryExpression(leftIdentifier, lua.createNilLiteral(), lua.SyntaxKind.InequalityOperator), lua.createBlock(innerStatements)));
+        return { expression: lua.createNilLiteral(), thisValue: returnThisValue };
+    }
+    else if (rightPrecedingStatements.length === 0 &&
+        !(0, typescript_1.canBeFalsyWhenNotNull)(context, context.checker.getTypeAtLocation(tsLeftExpression))) {
+        // return a && a.b
+        return {
+            expression: lua.createBinaryExpression(leftIdentifier, rightExpression, lua.SyntaxKind.AndOperator, tsNode),
+            thisValue: returnThisValue,
+        };
+    }
+    else {
+        let resultIdentifier;
+        if (!reuseLeftIdentifier) {
+            // reuse temp variable for output
+            resultIdentifier = leftIdentifier;
+        }
+        else {
+            resultIdentifier = lua.createIdentifier(context.createTempName("opt_result"), undefined, context_1.tempSymbolId);
+            context.addPrecedingStatements(lua.createVariableDeclarationStatement(resultIdentifier));
+        }
+        // if left ~= nil then
+        //   <right preceding statements>
+        //   result = <right expression>
+        // end
+        // return result
+        context.addPrecedingStatements(lua.createIfStatement(lua.createBinaryExpression(leftIdentifier, lua.createNilLiteral(), lua.SyntaxKind.InequalityOperator), lua.createBlock([
+            ...rightPrecedingStatements,
+            lua.createAssignmentStatement(resultIdentifier, rightExpression),
+        ])));
+        return { expression: resultIdentifier, thisValue: returnThisValue };
+    }
 }
 exports.transformOptionalChainWithCapture = transformOptionalChainWithCapture;
 function transformOptionalDeleteExpression(context, node, innerExpression) {

package/dist/transformation/visitors/void.js

@@ -8,7 +8,7 @@ const expression_statement_1 = require("./expression-statement");
 const transformVoidExpression = (node, context) => {
     // If content is a literal it is safe to replace the entire expression with nil
     if (!ts.isLiteralExpression(node.expression)) {
-        const statements = (0, expression_statement_1.transformExpressionToStatement)(context, node.expression);
+        const statements = (0, expression_statement_1.wrapInStatement)(context.transformExpression(node.expression));
         if (statements)
             context.addPrecedingStatements(statements);
     }

package/dist/transpilation/diagnostics.js

@@ -17,7 +17,7 @@ exports.usingLuaBundleWithInlineMightGenerateDuplicateCode = (0, utils_1.createS
     messageText: "Using 'luaBundle' with 'luaLibImport: \"inline\"' might generate duplicate code. " +
         "It is recommended to use 'luaLibImport: \"require\"'.",
 }));
-exports.cannotBundleLibrary = createDiagnosticFactory(() => 'Cannot bundle probjects with"buildmode": "library". Projects including the library can still bundle (which will include external library files).');
+exports.cannotBundleLibrary = createDiagnosticFactory(() => 'Cannot bundle projects with "buildmode": "library". Projects including the library can still bundle (which will include external library files).');
 exports.unsupportedJsxEmit = createDiagnosticFactory(() => 'JSX is only supported with "react" jsx option.');
 exports.pathsWithoutBaseUrl = createDiagnosticFactory(() => "When configuring 'paths' in tsconfig.json, the option 'baseUrl' must also be provided.");
 //# sourceMappingURL=diagnostics.js.map

package/dist/transpilation/find-lua-requires.d.ts

@@ -0,0 +1,6 @@
+export interface LuaRequire {
+    from: number;
+    to: number;
+    requirePath: string;
+}
+export declare function findLuaRequires(lua: string): LuaRequire[];

package/dist/transpilation/find-lua-requires.js

@@ -0,0 +1,145 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.findLuaRequires = void 0;
+function findLuaRequires(lua) {
+    return findRequire(lua, 0);
+}
+exports.findLuaRequires = findLuaRequires;
+function findRequire(lua, offset) {
+    const result = [];
+    while (offset < lua.length) {
+        const c = lua[offset];
+        if (c === "r" &&
+            (offset === 0 ||
+                isWhitespace(lua[offset - 1]) ||
+                lua[offset - 1] === "]" ||
+                lua[offset - 1] === "(" ||
+                lua[offset - 1] === "[")) {
+            const m = matchRequire(lua, offset);
+            if (m.matched) {
+                offset = m.match.to + 1;
+                result.push(m.match);
+            }
+            else {
+                offset = m.end;
+            }
+        }
+        else if (c === '"' || c === "'") {
+            offset = readString(lua, offset, c).offset; // Skip string and surrounding quotes
+        }
+        else if (c === "-" && offset + 1 < lua.length && lua[offset + 1] === "-") {
+            offset = skipComment(lua, offset);
+        }
+        else {
+            offset++;
+        }
+    }
+    return result;
+}
+function matchRequire(lua, offset) {
+    const start = offset;
+    for (const c of "require") {
+        if (offset > lua.length) {
+            return { matched: false, end: offset };
+        }
+        if (lua[offset] !== c) {
+            return { matched: false, end: offset };
+        }
+        offset++;
+    }
+    offset = skipWhitespace(lua, offset);
+    let hasParentheses = false;
+    if (offset > lua.length) {
+        return { matched: false, end: offset };
+    }
+    else {
+        if (lua[offset] === "(") {
+            hasParentheses = true;
+            offset++;
+            offset = skipWhitespace(lua, offset);
+        }
+        else if (lua[offset] === '"' || lua[offset] === "'") {
+            // require without parentheses
+        }
+        else {
+            // otherwise fail match
+            return { matched: false, end: offset };
+        }
+    }
+    if (offset > lua.length || (lua[offset] !== '"' && lua[offset] !== "'")) {
+        return { matched: false, end: offset };
+    }
+    const { value: requireString, offset: offsetAfterString } = readString(lua, offset, lua[offset]);
+    offset = offsetAfterString; // Skip string and surrounding quotes
+    if (hasParentheses) {
+        offset = skipWhitespace(lua, offset);
+        if (offset > lua.length || lua[offset] !== ")") {
+            return { matched: false, end: offset };
+        }
+        offset++;
+    }
+    return { matched: true, match: { from: start, to: offset - 1, requirePath: requireString } };
+}
+function readString(lua, offset, delimiter) {
+    expect(lua, offset, delimiter);
+    offset++;
+    let start = offset;
+    let result = "";
+    let escaped = false;
+    while (offset < lua.length && (lua[offset] !== delimiter || escaped)) {
+        if (lua[offset] === "\\" && !escaped) {
+            escaped = true;
+        }
+        else {
+            if (lua[offset] === delimiter) {
+                result += lua.slice(start, offset - 1);
+                start = offset;
+            }
+            escaped = false;
+        }
+        offset++;
+    }
+    if (offset < lua.length) {
+        expect(lua, offset, delimiter);
+    }
+    result += lua.slice(start, offset);
+    return { value: result, offset: offset + 1 };
+}
+function skipWhitespace(lua, offset) {
+    while (offset < lua.length && isWhitespace(lua[offset])) {
+        offset++;
+    }
+    return offset;
+}
+function isWhitespace(c) {
+    return c === " " || c === "\t" || c === "\r" || c === "\n";
+}
+function skipComment(lua, offset) {
+    expect(lua, offset, "-");
+    expect(lua, offset + 1, "-");
+    offset += 2;
+    if (offset + 1 < lua.length && lua[offset] === "[" && lua[offset + 1] === "[") {
+        return skipMultiLineComment(lua, offset);
+    }
+    else {
+        return skipSingleLineComment(lua, offset);
+    }
+}
+function skipMultiLineComment(lua, offset) {
+    while (offset < lua.length && !(lua[offset] === "]" && lua[offset - 1] === "]")) {
+        offset++;
+    }
+    return offset + 1;
+}
+function skipSingleLineComment(lua, offset) {
+    while (offset < lua.length && lua[offset] !== "\n") {
+        offset++;
+    }
+    return offset + 1;
+}
+function expect(lua, offset, char) {
+    if (lua[offset] !== char) {
+        throw new Error(`Expected ${char} at position ${offset} but found ${lua[offset]}`);
+    }
+}
+//# sourceMappingURL=find-lua-requires.js.map