@@ -39,8 +39,8 @@ export interface Scope {
     loopContinued?: LoopContinued;
     functionReturned?: boolean;
     asyncTryHasReturn?: boolean;
-    asyncTryHasBreak?: boolean;
-    asyncTryHasContinue?: LoopContinued;
+    tryHasBreak?: boolean;
+    tryHasContinue?: LoopContinued;
 }
 
 export interface HoistingResult {
@@ -96,7 +96,7 @@ export function findAsyncTryScopeInStack(context: TransformationContext): Scope
 }
 
 /** Like findAsyncTryScopeInStack, but also stops at Loop boundaries. */
-export function findAsyncTryScopeBeforeLoop(context: TransformationContext): Scope | undefined {
+export function findTryScopeBeforeLoop(context: TransformationContext): Scope | undefined {
     for (const scope of walkScopesUp(context)) {
         if (scope.type === ScopeType.Function || scope.type === ScopeType.Loop) return undefined;
         if (scope.type === ScopeType.Try || scope.type === ScopeType.Catch) return scope;
 
@@ -2,13 +2,12 @@ import * as ts from "typescript";
 import { LuaTarget } from "../../CompilerOptions";
 import * as lua from "../../LuaAST";
 import { FunctionVisitor } from "../context";
-import { findAsyncTryScopeBeforeLoop, findScope, LoopContinued, ScopeType } from "../utils/scope";
-import { isInAsyncFunction } from "../utils/typescript";
+import { findScope, findTryScopeBeforeLoop, LoopContinued, ScopeType } from "../utils/scope";
 
 export const transformBreakStatement: FunctionVisitor<ts.BreakStatement> = (breakStatement, context) => {
-    const tryScope = isInAsyncFunction(breakStatement) ? findAsyncTryScopeBeforeLoop(context) : undefined;
+    const tryScope = findTryScopeBeforeLoop(context);
     if (tryScope) {
-        tryScope.asyncTryHasBreak = true;
+        tryScope.tryHasBreak = true;
         return [
             lua.createAssignmentStatement(
                 lua.createIdentifier("____hasBroken"),
@@ -40,9 +39,9 @@ export const transformContinueStatement: FunctionVisitor<ts.ContinueStatement> =
         scope.loopContinued = continuedWith;
     }
 
-    const tryScope = isInAsyncFunction(statement) ? findAsyncTryScopeBeforeLoop(context) : undefined;
+    const tryScope = findTryScopeBeforeLoop(context);
     if (tryScope) {
-        tryScope.asyncTryHasContinue = continuedWith;
+        tryScope.tryHasContinue = continuedWith;
         return [
             lua.createAssignmentStatement(
                 lua.createIdentifier("____hasContinued"),
 
@@ -79,8 +79,8 @@ const transformAsyncTry: FunctionVisitor<ts.TryStatement> = (statement, context)
     chainCalls.push(lua.createExpressionStatement(promiseAwait, statement));
 
     const hasReturn = tryScope.asyncTryHasReturn ?? catchScope?.asyncTryHasReturn;
-    const hasBreak = tryScope.asyncTryHasBreak ?? catchScope?.asyncTryHasBreak;
-    const hasContinue = tryScope.asyncTryHasContinue ?? catchScope?.asyncTryHasContinue;
+    const hasBreak = tryScope.tryHasBreak ?? catchScope?.tryHasBreak;
+    const hasContinue = tryScope.tryHasContinue ?? catchScope?.tryHasContinue;
 
     // Build result in output order: flag declarations, awaiter, chain calls, post-checks
     const result: lua.Statement[] = [];
@@ -114,7 +114,12 @@ const transformAsyncTry: FunctionVisitor<ts.TryStatement> = (statement, context)
 
     if (hasBreak) {
         result.push(
-            lua.createIfStatement(lua.createIdentifier("____hasBroken"), lua.createBlock([lua.createBreakStatement()]))
+            lua.createIfStatement(
+                lua.createIdentifier("____hasBroken", statement),
+                lua.createBlock([lua.createBreakStatement(statement)], statement),
+                undefined,
+                statement
+            )
         );
     }
 
@@ -125,21 +130,30 @@ const transformAsyncTry: FunctionVisitor<ts.TryStatement> = (statement, context)
         const continueStatements: lua.Statement[] = [];
         switch (hasContinue) {
             case LoopContinued.WithGoto:
-                continueStatements.push(lua.createGotoStatement(label));
+                continueStatements.push(lua.createGotoStatement(label, statement));
                 break;
             case LoopContinued.WithContinue:
-                continueStatements.push(lua.createContinueStatement());
+                continueStatements.push(lua.createContinueStatement(statement));
                 break;
             case LoopContinued.WithRepeatBreak:
                 continueStatements.push(
-                    lua.createAssignmentStatement(lua.createIdentifier(label), lua.createBooleanLiteral(true))
+                    lua.createAssignmentStatement(
+                        lua.createIdentifier(label, statement),
+                        lua.createBooleanLiteral(true),
+                        statement
+                    )
                 );
-                continueStatements.push(lua.createBreakStatement());
+                continueStatements.push(lua.createBreakStatement(statement));
                 break;
         }
 
         result.push(
-            lua.createIfStatement(lua.createIdentifier("____hasContinued"), lua.createBlock(continueStatements))
+            lua.createIfStatement(
+                lua.createIdentifier("____hasContinued", statement),
+                lua.createBlock(continueStatements, statement),
+                undefined,
+                statement
+            )
         );
     }
 
@@ -153,7 +167,7 @@ export const transformTryStatement: FunctionVisitor<ts.TryStatement> = (statemen
 
     const tsTryBlock = statement.tryBlock;
     const tsCatchClause = statement.catchClause;
-    const [tryBlock] = transformScopeBlock(context, tsTryBlock, ScopeType.Try);
+    const [tryBlock, tryScope] = transformScopeBlock(context, tsTryBlock, ScopeType.Try);
 
     if (
         (context.options.luaTarget === LuaTarget.Lua50 || context.options.luaTarget === LuaTarget.Lua51) &&
@@ -180,11 +194,13 @@ export const transformTryStatement: FunctionVisitor<ts.TryStatement> = (statemen
     result.push(lua.createVariableDeclarationStatement(tryReturnIdentifiers, tryCall, tsTryBlock));
 
     const hasCatch = tsCatchClause && tsCatchClause.block.statements.length > 0;
+    let catchScope: Scope | undefined;
     if (hasCatch) {
         // local ____catchSuccess
         result.push(lua.createVariableDeclarationStatement(catchSuccessIdentifier, undefined, tsCatchClause));
 
-        const [catchFunction] = transformCatchClause(context, tsCatchClause);
+        const [catchFunction, cScope] = transformCatchClause(context, tsCatchClause);
+        catchScope = cScope;
 
         const catchIdentifier = lua.createIdentifier("____catch", tsCatchClause);
         result.push(lua.createVariableDeclarationStatement(catchIdentifier, catchFunction, tsCatchClause));
@@ -301,6 +317,71 @@ export const transformTryStatement: FunctionVisitor<ts.TryStatement> = (statemen
     );
     result.push(ifTrySuccessStatement);
 
+    // local ____hasBroken
+    // local ____hasContinued
+    const hasBreak = tryScope.tryHasBreak ?? catchScope?.tryHasBreak;
+    const hasContinue = tryScope.tryHasContinue ?? catchScope?.tryHasContinue;
+
+    if (hasBreak || hasContinue !== undefined) {
+        const flagDecls: lua.Identifier[] = [];
+        if (hasBreak) flagDecls.push(lua.createIdentifier("____hasBroken", statement));
+        if (hasContinue !== undefined) flagDecls.push(lua.createIdentifier("____hasContinued", statement));
+        result.unshift(lua.createVariableDeclarationStatement(flagDecls, undefined, statement));
+    }
+
+    // if ____hasBroken then
+    //     break
+    // end
+    if (hasBreak) {
+        result.push(
+            lua.createIfStatement(
+                lua.createIdentifier("____hasBroken", statement),
+                lua.createBlock([lua.createBreakStatement(statement)], statement),
+                undefined,
+                statement
+            )
+        );
+    }
+
+    // if ____hasContinued then
+    //     goto __continueN  (Lua 5.2+)
+    //     continue           (Luau)
+    //     __continueN = true; break  (Lua 5.0/5.1)
+    // end
+    if (hasContinue !== undefined) {
+        const loopScope = findScope(context, ScopeType.Loop);
+        const label = `__continue${loopScope?.id ?? ""}`;
+
+        const continueStatements: lua.Statement[] = [];
+        switch (hasContinue) {
+            case LoopContinued.WithGoto:
+                continueStatements.push(lua.createGotoStatement(label, statement));
+                break;
+            case LoopContinued.WithContinue:
+                continueStatements.push(lua.createContinueStatement(statement));
+                break;
+            case LoopContinued.WithRepeatBreak:
+                continueStatements.push(
+                    lua.createAssignmentStatement(
+                        lua.createIdentifier(label, statement),
+                        lua.createBooleanLiteral(true),
+                        statement
+                    )
+                );
+                continueStatements.push(lua.createBreakStatement(statement));
+                break;
+        }
+
+        result.push(
+            lua.createIfStatement(
+                lua.createIdentifier("____hasContinued", statement),
+                lua.createBlock(continueStatements, statement),
+                undefined,
+                statement
+            )
+        );
+    }
+
     return lua.createDoStatement(result, statement);
 };
 
 
@@ -689,6 +689,130 @@ test("try/finally rethrow with non-string error", () => {
     `.expectToMatchJsResult();
 });
 
+test("break inside try in loop", () => {
+    util.testFunction`
+        const result: number[] = [];
+        for (let i = 0; i < 5; i++) {
+            try {
+                if (i === 3) break;
+                result.push(i);
+            } catch {}
+        }
+        return result;
+    `.expectToMatchJsResult();
+});
+
+test("continue inside try in loop", () => {
+    util.testFunction`
+        const result: number[] = [];
+        for (let i = 0; i < 5; i++) {
+            try {
+                if (i === 2) continue;
+                result.push(i);
+            } catch {}
+        }
+        return result;
+    `.expectToMatchJsResult();
+});
+
+test("break inside catch in loop", () => {
+    util.testFunction`
+        const result: number[] = [];
+        for (let i = 0; i < 5; i++) {
+            try {
+                throw i;
+            } catch (e: any) {
+                if (e === 3) break;
+                result.push(e);
+            }
+        }
+        return result;
+    `.expectToMatchJsResult();
+});
+
+test("continue inside catch in loop", () => {
+    util.testFunction`
+        const result: number[] = [];
+        for (let i = 0; i < 5; i++) {
+            try {
+                throw i;
+            } catch (e: any) {
+                if (e === 2) continue;
+                result.push(e);
+            }
+        }
+        return result;
+    `.expectToMatchJsResult();
+});
+
+test("break inside try with finally in loop", () => {
+    util.testFunction`
+        const result: number[] = [];
+        let finallyCalls = 0;
+        for (let i = 0; i < 5; i++) {
+            try {
+                if (i === 3) break;
+                result.push(i);
+            } finally {
+                finallyCalls++;
+            }
+        }
+        return { result, finallyCalls };
+    `.expectToMatchJsResult();
+});
+
+test("continue inside try with finally in loop", () => {
+    util.testFunction`
+        const result: number[] = [];
+        let finallyCalls = 0;
+        for (let i = 0; i < 5; i++) {
+            try {
+                if (i === 2) continue;
+                result.push(i);
+            } finally {
+                finallyCalls++;
+            }
+        }
+        return { result, finallyCalls };
+    `.expectToMatchJsResult();
+});
+
+test("break inside catch with finally in loop", () => {
+    util.testFunction`
+        const result: number[] = [];
+        let finallyCalls = 0;
+        for (let i = 0; i < 5; i++) {
+            try {
+                throw i;
+            } catch (e: any) {
+                if (e === 3) break;
+                result.push(e);
+            } finally {
+                finallyCalls++;
+            }
+        }
+        return { result, finallyCalls };
+    `.expectToMatchJsResult();
+});
+
+test("continue inside catch with finally in loop", () => {
+    util.testFunction`
+        const result: number[] = [];
+        let finallyCalls = 0;
+        for (let i = 0; i < 5; i++) {
+            try {
+                throw i;
+            } catch (e: any) {
+                if (e === 2) continue;
+                result.push(e);
+            } finally {
+                finallyCalls++;
+            }
+        }
+        return { result, finallyCalls };
+    `.expectToMatchJsResult();
+});
+
 util.testEachVersion(
     "error stacktrace omits constructor and __TS_New",
     () => util.testFunction`