storm-lua-minify 0.1.3 → 0.2.0

package/src/output.ts

@@ -0,0 +1,71 @@
+import path from "path";
+import { SourceNode } from "source-map";
+
+export interface MinifiedOutput {
+  code: string;
+  map: string;
+}
+
+export type SourceMappingUrlStyle = "legacy" | "line" | "strict";
+
+export interface BuildMinifiedOutputOptions {
+  /**
+   * sourceMappingURLアノテーションの出力形式。省略時は"legacy"。
+   *
+   * - "legacy"（既定）: 旧storm-lua-minifyと同じ複数行の`--[[ ... ]]`ブロック
+   *   コメント（`--[[\n//# sourceMappingURL=...\n]]`）をそのまま出力する。
+   *   互換性優先で、この形式を前提に読み込む既存ツールと組み合わせて使う。
+   *   Source Map仕様が定める「アノテーションは生成コードの最後の行（末尾が
+   *   空行の場合はその直前の行）に置く」というルールには厳密には従わない
+   *   （アノテーション行の後に`]]`が続き最終行にならないため）。
+   * - "line": 単一行の`--`ラインコメント（`-- //# sourceMappingURL=...`）。
+   *   末尾の空行を除けば出力の最終行になるため「最終行ルール」は満たすが、
+   *   マーカー文字列自体は`-- `に続く形になる（行頭が厳密に`//`であることを
+   *   要求する一部のツールからは認識されない可能性がある）。有効なLuaの
+   *   ままである。
+   * - "strict": Luaコメントで一切包まず`//# sourceMappingURL=...`をそのまま
+   *   出力する。マーカー文字列・最終行ルールの両方を厳密に満たす。
+   *
+   *   【Lua文法との両立について】Lua 5.1〜5.4のどのバージョンでも`/`（除算）や
+   *   `//`（5.3以降の整数除算）は二項演算子のトークンであり、文の先頭に
+   *   来ることはできない（Luaの文は識別子・キーワード・`::`・`;`のいずれかで
+   *   始まらなければならない）。そのため`//`から始まる行を、一切のコメント化
+   *   なしにLuaの文として構文解析可能にする方法は存在しない。したがって
+   *   "strict"を選択した場合、出力ファイルの最終行は有効なLua文ではなくなる
+   *   （luaparseで再パースするとエラーになる）。この制約はLuaの言語仕様上
+   *   回避不能であることを確認済み。
+   */
+  sourceMappingUrlStyle?: SourceMappingUrlStyle;
+}
+
+/**
+ * ミニファイ済みSourceNodeに、sourceMappingURLアノテーションとSource Mapを
+ * 付加した最終的な出力を組み立てる。アノテーションの出力形式は
+ * `BuildMinifiedOutputOptions.sourceMappingUrlStyle`で選択する。
+ */
+export function buildMinifiedOutput(
+  sourceNode: SourceNode,
+  minFileName: string,
+  mapFileName: string,
+  options: BuildMinifiedOutputOptions = {},
+): MinifiedOutput {
+  const style = options.sourceMappingUrlStyle ?? "legacy";
+  const marker = "//# sourceMappingURL=" + path.basename(mapFileName);
+
+  if (style === "legacy") {
+    // 旧storm-lua-minifyと完全に同じ出力（末尾に改行は付加しない）。
+    sourceNode.add("\n--[[\n" + marker + "\n]]");
+  } else if (style === "line") {
+    sourceNode.add("\n-- " + marker + "\n");
+  } else {
+    sourceNode.add("\n" + marker + "\n");
+  }
+
+  const sourceAndMap = sourceNode.toStringWithSourceMap({
+    file: path.basename(minFileName),
+  });
+  return {
+    code: sourceAndMap.code,
+    map: JSON.stringify(sourceAndMap.map),
+  };
+}

package/src/renamer.ts

@@ -0,0 +1,134 @@
+// Renameパス（#20）: Resolveパス（#19）が構築したシンボルテーブルをもとに、
+// シンボル単位で短縮識別子を割り当てる。printer（ast2lua.ts）は出力時の
+// その場リネームを行わず、このパスが決めた名前を参照するだけになる。
+//
+// 割当は2段階で行う。
+//   1. スロット割当: スコープ木を辿り、各シンボルに整数のスロットを割り当てる。
+//      兄弟スコープ同士（親子関係にないスコープ同士）は生存区間が重ならないため、
+//      同じスロットを再利用できる（圧縮率の向上）。同一スコープ内のシンボル同士・
+//      祖先スコープのシンボルとは必ず異なるスロットになるため、シンボルの生存
+//      スコープ内で名前が衝突することはない。
+//   2. 名前割当: スロットごとの参照回数（頻度）を集計し、頻度の高いスロットから
+//      順に短い名前を割り当てる。頻度の高いシンボルほど短い名前になるため、
+//      同じスロット数でも出力サイズが最小化される。
+//
+// 予約語・"self"・呼び出し側が指定する予約名（グローバル参照やStormworks APIなど）
+// は、どのシンボルにも割り当てられない。
+import Parser from "luaparse";
+import { Scope, Symbol, ResolveResult } from "./resolver";
+import { IDENTIFIER_PARTS, isKeyword } from "./ast2lua";
+
+export interface RenameResult {
+  // identifierがResolveパスで解決済みのローカルシンボルに対応する場合、
+  // 割り当てられた短縮名を返す。グローバル参照やフィールド名など対応する
+  // シンボルが無い場合はundefinedを返す（呼び出し側は元の名前を使う）。
+  nameOf(identifier: Parser.Identifier): string | undefined;
+  // このモジュールが実際に割り当てた短縮名の集合。requireの展開先が
+  // 呼び出し元と同じLuaスコープに直接展開される場合（dofile等、関数で
+  // 包まれない展開）があるため、他モジュールの割当と衝突しないよう
+  // 呼び出し側（Minifier）はこれを後続モジュールの予約名に積み増す。
+  readonly usedNames: ReadonlySet<string>;
+}
+
+function isAvailable(id: string, reserved: ReadonlySet<string>): boolean {
+  return id !== "self" && !isKeyword(id) && !reserved.has(id);
+}
+
+// 0始まりのカウンタから短縮名候補を生成する（バイジェクティブ基数記数法）。
+// 通常の位取り記数法と違い同じ文字列を2つのカウンタ値が指すことがないため、
+// カウンタを増やし続けるだけで重複なく識別子候補を列挙できる。
+function generateCandidate(counter: number): string {
+  const l = IDENTIFIER_PARTS.length;
+  let num = counter + 1;
+  let id = "";
+  while (num > 0) {
+    const rem = (num - 1) % l;
+    id = IDENTIFIER_PARTS[rem] + id;
+    num = Math.floor((num - 1) / l);
+  }
+  return id;
+}
+
+/**
+ * スコープ木のDFSでシンボルごとにスロット番号を割り当てる。
+ * `active`は祖先スコープ（自分を含む）で既に使われているスロットの集合。
+ * 兄弟スコープには同じ`active`のコピーが渡されるため、互いの割当は影響しない。
+ */
+function assignSlots(
+  scope: Scope,
+  active: ReadonlySet<number>,
+): Map<Symbol, number> {
+  const slotOf = new Map<Symbol, number>();
+  const used = new Set(active);
+
+  scope.symbols.forEach((symbol) => {
+    let slot = 0;
+    while (used.has(slot)) {
+      slot++;
+    }
+    slotOf.set(symbol, slot);
+    used.add(slot);
+  });
+
+  scope.children.forEach((child) => {
+    assignSlots(child, used).forEach((slot, symbol) => {
+      slotOf.set(symbol, slot);
+    });
+  });
+
+  return slotOf;
+}
+
+export function assignRenames(
+  resolveResult: ResolveResult,
+  reserved: ReadonlySet<string>,
+): RenameResult {
+  const slotOf = assignSlots(resolveResult.chunkScope, new Set());
+
+  // スロットの通算参照回数（宣言自体も1回として数える）を集計する。
+  const weightOfSlot = new Map<number, number>();
+  resolveResult.symbols.forEach((symbol) => {
+    const slot = slotOf.get(symbol);
+    if (slot === undefined) {
+      return;
+    }
+    const weight = symbol.references.length + 1;
+    weightOfSlot.set(slot, (weightOfSlot.get(slot) ?? 0) + weight);
+  });
+
+  const orderedSlots = [...weightOfSlot.keys()].sort(
+    (a, b) => (weightOfSlot.get(b) ?? 0) - (weightOfSlot.get(a) ?? 0),
+  );
+
+  const nameOfSlot = new Map<number, string>();
+  let counter = 0;
+  orderedSlots.forEach((slot) => {
+    let candidate: string;
+    do {
+      candidate = generateCandidate(counter++);
+    } while (!isAvailable(candidate, reserved));
+    nameOfSlot.set(slot, candidate);
+  });
+
+  const nameOfSymbol = new Map<Symbol, string>();
+  slotOf.forEach((slot, symbol) => {
+    const name = nameOfSlot.get(slot);
+    if (name !== undefined) {
+      nameOfSymbol.set(symbol, name);
+    }
+  });
+
+  return {
+    nameOf: (identifier) => {
+      // メソッド定義の暗黙のselfパラメータは慣習的な名前のため常に維持する
+      // （呼び出し側から見える名前ではないため短縮しても安全ではあるが、
+      // 可読性のために元の名前のままにする）。
+      if (identifier.name === "self") {
+        return undefined;
+      }
+      const symbol = resolveResult.symbolOf(identifier);
+      return symbol ? nameOfSymbol.get(symbol) : undefined;
+    },
+    usedNames: new Set(nameOfSlot.values()),
+  };
+}

package/src/resolver.ts

@@ -0,0 +1,378 @@
+// Resolveパス（#19）: 宣言ごとに一意なシンボルを持つスコープツリーを構築し、
+// 識別子の参照を対応する宣言シンボルに解決する。グローバル参照も識別する。
+// このパスは解析のみを行い、ASTやその出力を一切変更しない。
+import Parser from "luaparse";
+
+export type SymbolKind = "local" | "param" | "for" | "label";
+
+export interface Scope {
+  readonly kind: "chunk" | "function" | "block";
+  readonly parent: Scope | null;
+  readonly children: Scope[];
+  // このスコープで直接宣言されたシンボル（宣言順。同名の再宣言もすべて含む）
+  readonly symbols: Symbol[];
+}
+
+export interface Symbol {
+  readonly id: number;
+  readonly name: string;
+  readonly kind: SymbolKind;
+  readonly scope: Scope;
+  readonly declaration: Parser.Identifier;
+  // このシンボルを指す参照（宣言箇所自体は含まない）
+  readonly references: Parser.Identifier[];
+}
+
+export interface GlobalBinding {
+  readonly name: string;
+  readonly references: Parser.Identifier[];
+}
+
+export interface ResolveResult {
+  readonly chunkScope: Scope;
+  // チャンク全体で宣言された全シンボル（宣言順）
+  readonly symbols: Symbol[];
+  readonly globals: Map<string, GlobalBinding>;
+  // 宣言・参照どちらの識別子ノードからも対応するシンボルを引ける。
+  // グローバル参照やフィールド名など、シンボルを持たない識別子はundefinedを返す。
+  symbolOf(identifier: Parser.Identifier): Symbol | undefined;
+}
+
+interface MutableScope extends Scope {
+  readonly parent: MutableScope | null;
+  readonly children: MutableScope[];
+  readonly bindings: Map<string, Symbol>;
+  readonly labels: Map<string, Symbol>;
+}
+
+export function resolveScopes(chunk: Parser.Chunk): ResolveResult {
+  let nextSymbolId = 0;
+  const allSymbols: Symbol[] = [];
+  const globals = new Map<string, GlobalBinding>();
+  const identifierSymbols = new WeakMap<Parser.Identifier, Symbol>();
+
+  function createScope(
+    kind: Scope["kind"],
+    parent: MutableScope | null,
+  ): MutableScope {
+    const scope: MutableScope = {
+      kind,
+      parent,
+      children: [],
+      symbols: [],
+      bindings: new Map(),
+      labels: new Map(),
+    };
+    parent?.children.push(scope);
+    return scope;
+  }
+
+  function declare(
+    scope: MutableScope,
+    node: Parser.Identifier,
+    kind: SymbolKind,
+  ): Symbol {
+    const symbol: Symbol = {
+      id: nextSymbolId++,
+      name: node.name,
+      kind,
+      scope,
+      declaration: node,
+      references: [],
+    };
+    // 同名の再宣言はスコープ内の以後の参照から見た束縛を上書きする（Luaの通常のシャドーイング）
+    scope.symbols.push(symbol);
+    scope.bindings.set(node.name, symbol);
+    allSymbols.push(symbol);
+    identifierSymbols.set(node, symbol);
+    return symbol;
+  }
+
+  function declareLabel(scope: MutableScope, node: Parser.Identifier): Symbol {
+    const symbol: Symbol = {
+      id: nextSymbolId++,
+      name: node.name,
+      kind: "label",
+      scope,
+      declaration: node,
+      references: [],
+    };
+    scope.symbols.push(symbol);
+    scope.labels.set(node.name, symbol);
+    allSymbols.push(symbol);
+    identifierSymbols.set(node, symbol);
+    return symbol;
+  }
+
+  function lookupBinding(
+    scope: MutableScope,
+    name: string,
+  ): Symbol | undefined {
+    for (let s: MutableScope | null = scope; s; s = s.parent) {
+      const found = s.bindings.get(name);
+      if (found) {
+        return found;
+      }
+    }
+    return undefined;
+  }
+
+  function lookupLabel(scope: MutableScope, name: string): Symbol | undefined {
+    for (let s: MutableScope | null = scope; s; s = s.parent) {
+      const found = s.labels.get(name);
+      if (found) {
+        return found;
+      }
+    }
+    return undefined;
+  }
+
+  function reference(scope: MutableScope, node: Parser.Identifier) {
+    const symbol = lookupBinding(scope, node.name);
+    if (symbol) {
+      symbol.references.push(node);
+      identifierSymbols.set(node, symbol);
+      return;
+    }
+    let binding = globals.get(node.name);
+    if (!binding) {
+      binding = { name: node.name, references: [] };
+      globals.set(node.name, binding);
+    }
+    binding.references.push(node);
+  }
+
+  // ラベルはブロック内での宣言位置に関わらずブロック全体から参照できる
+  // （前方goto）ため、通常の宣言文と違い先読みで登録する。
+  function hoistLabels(body: Parser.Statement[], scope: MutableScope) {
+    body.forEach((statement) => {
+      if (statement.type === "LabelStatement") {
+        declareLabel(scope, statement.label);
+      }
+    });
+  }
+
+  function resolveBlock(body: Parser.Statement[], scope: MutableScope) {
+    hoistLabels(body, scope);
+    body.forEach((statement) => {
+      resolveStatement(statement, scope);
+    });
+  }
+
+  function resolveStatement(
+    statement: Parser.Statement,
+    scope: MutableScope,
+  ): void {
+    switch (statement.type) {
+      case "LocalStatement":
+        // 初期化式は新しいローカルが宣言される前の束縛で解決する
+        // （`local x = x` の右辺は外側のxを指す）
+        statement.init.forEach((expr) => {
+          resolveExpression(expr, scope);
+        });
+        statement.variables.forEach((v) => declare(scope, v, "local"));
+        return;
+      case "AssignmentStatement":
+        statement.init.forEach((expr) => {
+          resolveExpression(expr, scope);
+        });
+        statement.variables.forEach((v) => {
+          if (v.type === "Identifier") {
+            reference(scope, v);
+          } else {
+            resolveExpression(v, scope);
+          }
+        });
+        return;
+      case "CallStatement":
+        resolveExpression(statement.expression, scope);
+        return;
+      case "DoStatement": {
+        const inner = createScope("block", scope);
+        resolveBlock(statement.body, inner);
+        return;
+      }
+      case "WhileStatement": {
+        resolveExpression(statement.condition, scope);
+        const inner = createScope("block", scope);
+        resolveBlock(statement.body, inner);
+        return;
+      }
+      case "RepeatStatement": {
+        // `until`の条件式は本体で宣言されたローカルを参照できる
+        const inner = createScope("block", scope);
+        resolveBlock(statement.body, inner);
+        resolveExpression(statement.condition, inner);
+        return;
+      }
+      case "IfStatement":
+        statement.clauses.forEach((clause) => {
+          if (clause.type !== "ElseClause") {
+            resolveExpression(clause.condition, scope);
+          }
+          const inner = createScope("block", scope);
+          resolveBlock(clause.body, inner);
+        });
+        return;
+      case "ForNumericStatement": {
+        resolveExpression(statement.start, scope);
+        resolveExpression(statement.end, scope);
+        if (statement.step) {
+          resolveExpression(statement.step, scope);
+        }
+        const inner = createScope("block", scope);
+        declare(inner, statement.variable, "for");
+        resolveBlock(statement.body, inner);
+        return;
+      }
+      case "ForGenericStatement": {
+        statement.iterators.forEach((iterator) => {
+          resolveExpression(iterator, scope);
+        });
+        const inner = createScope("block", scope);
+        statement.variables.forEach((v) => declare(inner, v, "for"));
+        resolveBlock(statement.body, inner);
+        return;
+      }
+      case "FunctionDeclaration":
+        resolveFunctionDeclaration(statement, scope);
+        return;
+      case "ReturnStatement":
+        statement.arguments.forEach((argument) => {
+          resolveExpression(argument, scope);
+        });
+        return;
+      case "BreakStatement":
+        return;
+      case "LabelStatement":
+        // hoistLabelsで宣言済みのため、ここでは何もしない
+        return;
+      case "GotoStatement": {
+        const symbol = lookupLabel(scope, statement.label.name);
+        if (symbol) {
+          symbol.references.push(statement.label);
+          identifierSymbols.set(statement.label, symbol);
+        }
+        return;
+      }
+      default: {
+        const exhaustive: never = statement;
+        throw new TypeError(
+          "Unknown statement type: `" + JSON.stringify(exhaustive) + "`",
+        );
+      }
+    }
+  }
+
+  function resolveFunctionDeclaration(
+    fn: Parser.FunctionDeclaration,
+    scope: MutableScope,
+  ) {
+    if (fn.identifier) {
+      if (fn.identifier.type === "Identifier") {
+        if (fn.isLocal) {
+          // `local function`は再帰呼び出しのため、本体を解決する前に自身を宣言する
+          declare(scope, fn.identifier, "local");
+        } else {
+          // 非local: 既存のローカル/グローバルへの代入として扱う（新規宣言ではない）
+          reference(scope, fn.identifier);
+        }
+      } else {
+        resolveExpression(fn.identifier, scope);
+      }
+    }
+    const inner = createScope("function", scope);
+    fn.parameters.forEach((parameter) => {
+      if (parameter.type === "Identifier") {
+        declare(inner, parameter, "param");
+      }
+    });
+    resolveBlock(fn.body, inner);
+  }
+
+  function resolveExpression(
+    expr: Parser.Expression,
+    scope: MutableScope,
+  ): void {
+    switch (expr.type) {
+      case "Identifier":
+        reference(scope, expr);
+        return;
+      case "StringLiteral":
+      case "NumericLiteral":
+      case "BooleanLiteral":
+      case "NilLiteral":
+      case "VarargLiteral":
+        return;
+      case "LogicalExpression":
+      case "BinaryExpression":
+        resolveExpression(expr.left, scope);
+        resolveExpression(expr.right, scope);
+        return;
+      case "UnaryExpression":
+        resolveExpression(expr.argument, scope);
+        return;
+      case "CallExpression":
+        resolveExpression(expr.base, scope);
+        expr.arguments.forEach((argument) => {
+          resolveExpression(argument, scope);
+        });
+        return;
+      case "TableCallExpression":
+        resolveExpression(expr.base, scope);
+        resolveExpression(expr.arguments, scope);
+        return;
+      case "StringCallExpression":
+        resolveExpression(expr.base, scope);
+        resolveExpression(expr.argument, scope);
+        return;
+      case "IndexExpression":
+        resolveExpression(expr.base, scope);
+        resolveExpression(expr.index, scope);
+        return;
+      case "MemberExpression":
+        resolveExpression(expr.base, scope);
+        // フィールド名（`.identifier`）は変数参照ではないため解決しない
+        return;
+      case "FunctionDeclaration": {
+        const inner = createScope("function", scope);
+        expr.parameters.forEach((parameter) => {
+          if (parameter.type === "Identifier") {
+            declare(inner, parameter, "param");
+          }
+        });
+        resolveBlock(expr.body, inner);
+        return;
+      }
+      case "TableConstructorExpression":
+        expr.fields.forEach((field) => {
+          if (field.type === "TableKey") {
+            resolveExpression(field.key, scope);
+            resolveExpression(field.value, scope);
+          } else if (field.type === "TableValue") {
+            resolveExpression(field.value, scope);
+          } else {
+            // TableKeyString: キー名（`{ key = value }`のkey）は変数参照ではない
+            resolveExpression(field.value, scope);
+          }
+        });
+        return;
+      default: {
+        const exhaustive: never = expr;
+        throw new TypeError(
+          "Unknown expression type: `" + JSON.stringify(exhaustive) + "`",
+        );
+      }
+    }
+  }
+
+  const chunkScope = createScope("chunk", null);
+  resolveBlock(chunk.body, chunkScope);
+
+  return {
+    chunkScope,
+    symbols: allSymbols,
+    globals,
+    symbolOf: (identifier) => identifierSymbols.get(identifier),
+  };
+}

package/test/circular-require.test.ts

@@ -0,0 +1,19 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import { Minifier } from "../src/minifier";
+import { LUAPARSE_SETTINGS, fixtureEntryPath } from "./lib/helpers";
+
+// require/dofileの参照グラフに循環がある場合、Linkパスがエラーを投げて
+// 出力を開始しないことを検証する（#18）。
+
+void test("circular require is rejected with a clear error", () => {
+  const minifier = new Minifier(
+    fixtureEntryPath("circular-require"),
+    LUAPARSE_SETTINGS,
+    { moduleLikeLua: true },
+  );
+  assert.throws(
+    () => minifier.parse(),
+    /Circular require\/dofile detected: a -> b -> a/,
+  );
+});

package/test/fixtures/bare-require/main.lua

@@ -0,0 +1,2 @@
+require("mod")
+print("done")

package/test/fixtures/bare-require/mod.lua

@@ -0,0 +1 @@
+print("hello from mod")

package/test/fixtures/bitwise-precedence/main.lua

@@ -0,0 +1,10 @@
+local a, b, c = 1, 2, 3
+
+print(a | b & c)
+print((a | b) & c)
+print(a & b | c)
+print(a ~ b & c)
+print(a << b + c)
+print((a << b) + c)
+print(a // b // c)
+print(~a & b)

package/test/fixtures/circular-require/a.lua

@@ -0,0 +1,2 @@
+local b = require("b")
+return { fromA = b }

package/test/fixtures/circular-require/b.lua

@@ -0,0 +1,2 @@
+local a = require("a")
+return { fromB = a }

package/test/fixtures/circular-require/main.lua

@@ -0,0 +1,2 @@
+local a = require("a")
+print(a)

package/test/fixtures/dofile/greet.lua

@@ -0,0 +1 @@
+print("hello from greet")

package/test/fixtures/dofile/main.lua

@@ -0,0 +1,2 @@
+dofile("greet")
+print("done")

package/test/fixtures/entry-scope-many-requires/dep_alpha.lua

@@ -0,0 +1,2 @@
+local valueAlpha = "dep_alpha"
+return { id = valueAlpha }

package/test/fixtures/entry-scope-many-requires/dep_bravo.lua

@@ -0,0 +1,2 @@
+local valueBravo = "dep_bravo"
+return { id = valueBravo }

package/test/fixtures/entry-scope-many-requires/dep_charlie.lua

@@ -0,0 +1,2 @@
+local valueCharlie = "dep_charlie"
+return { id = valueCharlie }

package/test/fixtures/entry-scope-many-requires/dep_delta.lua

@@ -0,0 +1,2 @@
+local valueDelta = "dep_delta"
+return { id = valueDelta }

package/test/fixtures/entry-scope-many-requires/dep_echo.lua

@@ -0,0 +1,2 @@
+local valueEcho = "dep_echo"
+return { id = valueEcho }

package/test/fixtures/entry-scope-many-requires/dep_foxtrot.lua

@@ -0,0 +1,2 @@
+local valueFoxtrot = "dep_foxtrot"
+return { id = valueFoxtrot }

package/test/fixtures/entry-scope-many-requires/dep_golf.lua

@@ -0,0 +1,2 @@
+local valueGolf = "dep_golf"
+return { id = valueGolf }

package/test/fixtures/entry-scope-many-requires/dep_hotel.lua

@@ -0,0 +1,2 @@
+local valueHotel = "dep_hotel"
+return { id = valueHotel }

package/test/fixtures/entry-scope-many-requires/dep_india.lua

@@ -0,0 +1,2 @@
+local valueIndia = "dep_india"
+return { id = valueIndia }

package/test/fixtures/entry-scope-many-requires/dep_juliet.lua

@@ -0,0 +1,2 @@
+local valueJuliet = "dep_juliet"
+return { id = valueJuliet }