sh-ast 0.1.0 → 0.2.0

package/dist/errors.d.ts

@@ -1,18 +1,28 @@
 import type { ShellDialect } from './types.js';
 /**
  * Common base class for every error this package throws — originally just
- * {@link parseSync}'s errors, now also the `sh-ast/analyze` layer's (see
- * {@link ShAnalyzeMaxDepthError}). Provides a stable, documented `code`
- * discriminator (e.g. `"ESLINT_SH_PARSE_ERROR"`) alongside the usual
+ * {@link sh-ast#parseSync | parseSync}'s errors, now also the
+ * `sh-ast/analyze` layer's (see {@link ShAnalyzeMaxDepthError},
+ * {@link ShAnalyzeInvalidWrapperSpecError}). Provides a stable, documented
+ * `code` discriminator (e.g. `"SH_AST_PARSE_ERROR"`) alongside the usual
  * `instanceof` narrowing, so consumers can branch on failure kind
- * programmatically without parsing `.message` strings. Never thrown
- * directly — only via its concrete subclasses ({@link ShParseError},
- * {@link ShInvalidDialectError}, {@link ShBridgeInternalError},
- * {@link ShAnalyzeMaxDepthError}).
+ * programmatically without parsing `.message` strings. Never thrown directly
+ * — only via its concrete subclasses
+ * ({@link sh-ast#ShParseError | ShParseError},
+ * {@link sh-ast#ShInvalidDialectError | ShInvalidDialectError},
+ * {@link sh-ast#ShInternalError | ShInternalError},
+ * {@link ShAnalyzeMaxDepthError},
+ * {@link sh-ast#ShParseMaxDepthError | ShParseMaxDepthError},
+ * {@link ShAnalyzeInvalidWrapperSpecError}).
+ *
+ * Re-exported from `sh-ast/analyze` as well as the root `sh-ast` entry
+ * point (see #23) — every subclass thrown by `sh-ast/analyze`'s own
+ * functions extends this, so a consumer of that subpath alone can
+ * `catch`/reference the base without also importing from root.
  *
  * @public
  */
-export declare abstract class ShBridgeError extends Error {
+export declare abstract class ShAstError extends Error {
     /**
      * Stable, machine-readable discriminator for this error kind. Distinct
      * per subclass and will not change once published.
@@ -51,8 +61,8 @@ export interface ShParseErrorInfo {
  *
  * @public
  */
-export declare class ShParseError extends ShBridgeError {
-    readonly code = "ESLINT_SH_PARSE_ERROR";
+export declare class ShParseError extends ShAstError {
+    readonly code = "SH_AST_PARSE_ERROR";
     readonly line: number;
     readonly column: number;
     readonly filename: string;
@@ -66,8 +76,8 @@ export declare class ShParseError extends ShBridgeError {
  *
  * @public
  */
-export declare class ShInvalidDialectError extends ShBridgeError {
-    readonly code = "ESLINT_SH_INVALID_DIALECT";
+export declare class ShInvalidDialectError extends ShAstError {
+    readonly code = "SH_AST_INVALID_DIALECT";
     /** The rejected dialect value, exactly as passed to {@link parseSync}. */
     readonly dialect: string;
     constructor(dialect: string, supportedDialects: readonly ShellDialect[]);
@@ -82,8 +92,8 @@ export declare class ShInvalidDialectError extends ShBridgeError {
  *
  * @public
  */
-export declare class ShBridgeInternalError extends ShBridgeError {
-    readonly code = "ESLINT_SH_BRIDGE_INTERNAL";
+export declare class ShInternalError extends ShAstError {
+    readonly code = "SH_AST_INTERNAL";
     constructor(message: string);
 }
 /**
@@ -106,10 +116,65 @@ export declare class ShBridgeInternalError extends ShBridgeError {
  *
  * @public
  */
-export declare class ShAnalyzeMaxDepthError extends ShBridgeError {
-    readonly code = "ESLINT_SH_ANALYZE_MAX_DEPTH";
+export declare class ShAnalyzeMaxDepthError extends ShAstError {
+    readonly code = "SH_AST_ANALYZE_MAX_DEPTH";
     /** The maximum nesting depth `enumerateCommands` supports; the same value every time (not caller-configurable). */
     readonly maxDepth: number;
     constructor(maxDepth: number);
 }
+/**
+ * Thrown by {@link parseSync} when `text`'s conservatively estimated
+ * structural nesting depth (subshells, command/process substitutions,
+ * `if`/`case`/loop/function bodies, `{ }` blocks, backtick or `$(...)`
+ * command substitution, `$((...))` arithmetic — see
+ * `parse-depth-guard.ts`'s module doc for the exact heuristic) exceeds the
+ * limit `parseSync` accepts. Thrown *before* `text` is ever handed to the
+ * WASM shim: mvdan/sh's own recursive-descent parser has no recovery path
+ * for exhausting its call stack on pathologically deep input (a stack
+ * overflow deep inside the shared WASM instance is not a normal, catchable
+ * JS error the way a parse syntax error is), so this bridge estimates the
+ * risk up front and fails closed with a typed error instead of ever making
+ * that call — the shared WASM instance is therefore never put at risk of
+ * wedging on this class of input; a `parseSync` call right after catching
+ * this error works exactly as it would if this input had never been
+ * attempted.
+ *
+ * Like {@link ShAnalyzeMaxDepthError}, this is pathological-input
+ * protection, not a normal-usage ceiling: a legitimately deep (but
+ * realistic) script parses fine. The estimate can *over*-count relative to
+ * mvdan/sh's real grammar (rejecting some legitimate-but-unusually-deep
+ * input) but is designed to never *under*-count relative to it — see
+ * `parse-depth-guard.ts` for the documented false-positive sources this
+ * trades off against ever letting a genuinely crash-inducing input
+ * through.
+ *
+ * @public
+ */
+export declare class ShParseMaxDepthError extends ShAstError {
+    readonly code = "SH_AST_PARSE_MAX_DEPTH";
+    /** The maximum structural nesting depth `parseSync` accepts; the same value every time (not caller-configurable). */
+    readonly maxDepth: number;
+    /**
+     * The conservatively estimated nesting depth that tripped the guard.
+     * Not necessarily `text`'s "true" nesting depth under a real parse — see
+     * {@link ShParseMaxDepthError}'s doc comment — only ever `> maxDepth`.
+     */
+    readonly estimatedDepth: number;
+    constructor(maxDepth: number, estimatedDepth: number);
+}
+/**
+ * Thrown by `sh-ast/analyze`'s `resolveArgv0` when a caller-supplied
+ * `options.transparentWrappers` array contains a malformed `WrapperSpec`
+ * entry — e.g. a non-array or empty `names`, or a flag field that isn't an
+ * array of strings. Fails closed with a clear, specific message at the
+ * point the malformed table is supplied, rather than letting the bad shape
+ * reach flag-matching logic and surface as a confusing native `TypeError`
+ * (or, worse, a silently wrong match) far from its actual cause.
+ *
+ * @public
+ */
+export declare class ShAnalyzeInvalidWrapperSpecError extends ShAstError {
+    readonly code = "SH_AST_ANALYZE_INVALID_WRAPPER_SPEC";
+    constructor(message: string);
+}
 //# sourceMappingURL=errors.d.ts.map

package/dist/errors.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C;;;;;;;;;;;;GAYG;AACH,8BAAsB,aAAc,SAAQ,KAAK;IAC/C;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CAChC;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,4DAA4D;IAC5D,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;;OAOG;IACH,MAAM,EAAE,MAAM,CAAC;IACf,2EAA2E;IAC3E,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,YAAa,SAAQ,aAAa;IAC7C,QAAQ,CAAC,IAAI,2BAA2B;IACxC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;gBAEd,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,gBAAgB;CAOpD;AAED;;;;;;;GAOG;AACH,qBAAa,qBAAsB,SAAQ,aAAa;IACtD,QAAQ,CAAC,IAAI,+BAA+B;IAC5C,0EAA0E;IAC1E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;gBAEb,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,SAAS,YAAY,EAAE;CAOxE;AAED;;;;;;;;;GASG;AACH,qBAAa,qBAAsB,SAAQ,aAAa;IACtD,QAAQ,CAAC,IAAI,+BAA+B;gBAEhC,OAAO,EAAE,MAAM;CAI5B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,sBAAuB,SAAQ,aAAa;IACvD,QAAQ,CAAC,IAAI,iCAAiC;IAC9C,mHAAmH;IACnH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;gBAEd,QAAQ,EAAE,MAAM;CAO7B"}
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,YAAY,CAAC;AAE/C;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,8BAAsB,UAAW,SAAQ,KAAK;IAC5C;;;OAGG;IACH,QAAQ,CAAC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CAChC;AAED;;;;GAIG;AACH,MAAM,WAAW,gBAAgB;IAC/B,4DAA4D;IAC5D,IAAI,EAAE,MAAM,CAAC;IACb;;;;;;;OAOG;IACH,MAAM,EAAE,MAAM,CAAC;IACf,2EAA2E;IAC3E,QAAQ,EAAE,MAAM,CAAC;CAClB;AAED;;;;;;;;;;;GAWG;AACH,qBAAa,YAAa,SAAQ,UAAU;IAC1C,QAAQ,CAAC,IAAI,wBAAwB;IACrC,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;IACtB,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAC;IACxB,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;gBAEd,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,gBAAgB;CAOpD;AAED;;;;;;;GAOG;AACH,qBAAa,qBAAsB,SAAQ,UAAU;IACnD,QAAQ,CAAC,IAAI,4BAA4B;IACzC,0EAA0E;IAC1E,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;gBAEb,OAAO,EAAE,MAAM,EAAE,iBAAiB,EAAE,SAAS,YAAY,EAAE;CAOxE;AAED;;;;;;;;;GASG;AACH,qBAAa,eAAgB,SAAQ,UAAU;IAC7C,QAAQ,CAAC,IAAI,qBAAqB;gBAEtB,OAAO,EAAE,MAAM;CAI5B;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,qBAAa,sBAAuB,SAAQ,UAAU;IACpD,QAAQ,CAAC,IAAI,8BAA8B;IAC3C,mHAAmH;IACnH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;gBAEd,QAAQ,EAAE,MAAM;CAO7B;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,qBAAa,oBAAqB,SAAQ,UAAU;IAClD,QAAQ,CAAC,IAAI,4BAA4B;IACzC,qHAAqH;IACrH,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;gBAEpB,QAAQ,EAAE,MAAM,EAAE,cAAc,EAAE,MAAM;CAQrD;AAED;;;;;;;;;;GAUG;AACH,qBAAa,gCAAiC,SAAQ,UAAU;IAC9D,QAAQ,CAAC,IAAI,yCAAyC;gBAE1C,OAAO,EAAE,MAAM;CAI5B"}

package/dist/errors.js

@@ -1,17 +1,27 @@
 /**
  * Common base class for every error this package throws — originally just
- * {@link parseSync}'s errors, now also the `sh-ast/analyze` layer's (see
- * {@link ShAnalyzeMaxDepthError}). Provides a stable, documented `code`
- * discriminator (e.g. `"ESLINT_SH_PARSE_ERROR"`) alongside the usual
+ * {@link sh-ast#parseSync | parseSync}'s errors, now also the
+ * `sh-ast/analyze` layer's (see {@link ShAnalyzeMaxDepthError},
+ * {@link ShAnalyzeInvalidWrapperSpecError}). Provides a stable, documented
+ * `code` discriminator (e.g. `"SH_AST_PARSE_ERROR"`) alongside the usual
  * `instanceof` narrowing, so consumers can branch on failure kind
- * programmatically without parsing `.message` strings. Never thrown
- * directly — only via its concrete subclasses ({@link ShParseError},
- * {@link ShInvalidDialectError}, {@link ShBridgeInternalError},
- * {@link ShAnalyzeMaxDepthError}).
+ * programmatically without parsing `.message` strings. Never thrown directly
+ * — only via its concrete subclasses
+ * ({@link sh-ast#ShParseError | ShParseError},
+ * {@link sh-ast#ShInvalidDialectError | ShInvalidDialectError},
+ * {@link sh-ast#ShInternalError | ShInternalError},
+ * {@link ShAnalyzeMaxDepthError},
+ * {@link sh-ast#ShParseMaxDepthError | ShParseMaxDepthError},
+ * {@link ShAnalyzeInvalidWrapperSpecError}).
+ *
+ * Re-exported from `sh-ast/analyze` as well as the root `sh-ast` entry
+ * point (see #23) — every subclass thrown by `sh-ast/analyze`'s own
+ * functions extends this, so a consumer of that subpath alone can
+ * `catch`/reference the base without also importing from root.
  *
  * @public
  */
-export class ShBridgeError extends Error {
+export class ShAstError extends Error {
 }
 /**
  * Thrown by {@link parseSync} when shell source fails to parse. Carries the
@@ -25,8 +35,8 @@ export class ShBridgeError extends Error {
  *
  * @public
  */
-export class ShParseError extends ShBridgeError {
-    code = 'ESLINT_SH_PARSE_ERROR';
+export class ShParseError extends ShAstError {
+    code = 'SH_AST_PARSE_ERROR';
     line;
     column;
     filename;
@@ -46,8 +56,8 @@ export class ShParseError extends ShBridgeError {
  *
  * @public
  */
-export class ShInvalidDialectError extends ShBridgeError {
-    code = 'ESLINT_SH_INVALID_DIALECT';
+export class ShInvalidDialectError extends ShAstError {
+    code = 'SH_AST_INVALID_DIALECT';
     /** The rejected dialect value, exactly as passed to {@link parseSync}. */
     dialect;
     constructor(dialect, supportedDialects) {
@@ -66,11 +76,11 @@ export class ShInvalidDialectError extends ShBridgeError {
  *
  * @public
  */
-export class ShBridgeInternalError extends ShBridgeError {
-    code = 'ESLINT_SH_BRIDGE_INTERNAL';
+export class ShInternalError extends ShAstError {
+    code = 'SH_AST_INTERNAL';
     constructor(message) {
         super(message);
-        this.name = 'ShBridgeInternalError';
+        this.name = 'ShInternalError';
     }
 }
 /**
@@ -93,8 +103,8 @@ export class ShBridgeInternalError extends ShBridgeError {
  *
  * @public
  */
-export class ShAnalyzeMaxDepthError extends ShBridgeError {
-    code = 'ESLINT_SH_ANALYZE_MAX_DEPTH';
+export class ShAnalyzeMaxDepthError extends ShAstError {
+    code = 'SH_AST_ANALYZE_MAX_DEPTH';
     /** The maximum nesting depth `enumerateCommands` supports; the same value every time (not caller-configurable). */
     maxDepth;
     constructor(maxDepth) {
@@ -103,4 +113,67 @@ export class ShAnalyzeMaxDepthError extends ShBridgeError {
         this.maxDepth = maxDepth;
     }
 }
+/**
+ * Thrown by {@link parseSync} when `text`'s conservatively estimated
+ * structural nesting depth (subshells, command/process substitutions,
+ * `if`/`case`/loop/function bodies, `{ }` blocks, backtick or `$(...)`
+ * command substitution, `$((...))` arithmetic — see
+ * `parse-depth-guard.ts`'s module doc for the exact heuristic) exceeds the
+ * limit `parseSync` accepts. Thrown *before* `text` is ever handed to the
+ * WASM shim: mvdan/sh's own recursive-descent parser has no recovery path
+ * for exhausting its call stack on pathologically deep input (a stack
+ * overflow deep inside the shared WASM instance is not a normal, catchable
+ * JS error the way a parse syntax error is), so this bridge estimates the
+ * risk up front and fails closed with a typed error instead of ever making
+ * that call — the shared WASM instance is therefore never put at risk of
+ * wedging on this class of input; a `parseSync` call right after catching
+ * this error works exactly as it would if this input had never been
+ * attempted.
+ *
+ * Like {@link ShAnalyzeMaxDepthError}, this is pathological-input
+ * protection, not a normal-usage ceiling: a legitimately deep (but
+ * realistic) script parses fine. The estimate can *over*-count relative to
+ * mvdan/sh's real grammar (rejecting some legitimate-but-unusually-deep
+ * input) but is designed to never *under*-count relative to it — see
+ * `parse-depth-guard.ts` for the documented false-positive sources this
+ * trades off against ever letting a genuinely crash-inducing input
+ * through.
+ *
+ * @public
+ */
+export class ShParseMaxDepthError extends ShAstError {
+    code = 'SH_AST_PARSE_MAX_DEPTH';
+    /** The maximum structural nesting depth `parseSync` accepts; the same value every time (not caller-configurable). */
+    maxDepth;
+    /**
+     * The conservatively estimated nesting depth that tripped the guard.
+     * Not necessarily `text`'s "true" nesting depth under a real parse — see
+     * {@link ShParseMaxDepthError}'s doc comment — only ever `> maxDepth`.
+     */
+    estimatedDepth;
+    constructor(maxDepth, estimatedDepth) {
+        super(`parseSync: input's estimated structural nesting depth (${String(estimatedDepth)}+ frames) exceeds the maximum this bridge accepts (${String(maxDepth)}) — refusing to hand this input to the WASM parser, which would risk exhausting its call stack uncatchably. Treat this as a deny signal, not "input looks fine".`);
+        this.name = 'ShParseMaxDepthError';
+        this.maxDepth = maxDepth;
+        this.estimatedDepth = estimatedDepth;
+    }
+}
+/**
+ * Thrown by `sh-ast/analyze`'s `resolveArgv0` when a caller-supplied
+ * `options.transparentWrappers` array contains a malformed `WrapperSpec`
+ * entry — e.g. a non-array or empty `names`, or a flag field that isn't an
+ * array of strings. Fails closed with a clear, specific message at the
+ * point the malformed table is supplied, rather than letting the bad shape
+ * reach flag-matching logic and surface as a confusing native `TypeError`
+ * (or, worse, a silently wrong match) far from its actual cause.
+ *
+ * @public
+ */
+export class ShAnalyzeInvalidWrapperSpecError extends ShAstError {
+    code = 'SH_AST_ANALYZE_INVALID_WRAPPER_SPEC';
+    constructor(message) {
+        super(`resolveArgv0: invalid transparentWrappers entry — ${message}`);
+        this.name = 'ShAnalyzeInvalidWrapperSpecError';
+    }
+}
 //# sourceMappingURL=errors.js.map

package/dist/errors.js.map

@@ -1 +1 @@
-{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH,MAAM,OAAgB,aAAc,SAAQ,KAAK;CAMhD;AAuBD;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,YAAa,SAAQ,aAAa;IACpC,IAAI,GAAG,uBAAuB,CAAC;IAC/B,IAAI,CAAS;IACb,MAAM,CAAS;IACf,QAAQ,CAAS;IAE1B,YAAY,OAAe,EAAE,IAAsB;QACjD,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,cAAc,CAAC;QAC3B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACtB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAC1B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;IAChC,CAAC;CACF;AAED;;;;;;;GAOG;AACH,MAAM,OAAO,qBAAsB,SAAQ,aAAa;IAC7C,IAAI,GAAG,2BAA2B,CAAC;IAC5C,0EAA0E;IACjE,OAAO,CAAS;IAEzB,YAAY,OAAe,EAAE,iBAA0C;QACrE,KAAK,CACH,uCAAuC,OAAO,8BAA8B,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAC3G,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,uBAAuB,CAAC;QACpC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;CACF;AAED;;;;;;;;;GASG;AACH,MAAM,OAAO,qBAAsB,SAAQ,aAAa;IAC7C,IAAI,GAAG,2BAA2B,CAAC;IAE5C,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,uBAAuB,CAAC;IACtC,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,OAAO,sBAAuB,SAAQ,aAAa;IAC9C,IAAI,GAAG,6BAA6B,CAAC;IAC9C,mHAAmH;IAC1G,QAAQ,CAAS;IAE1B,YAAY,QAAgB;QAC1B,KAAK,CACH,+EAA+E,MAAM,CAAC,QAAQ,CAAC,uGAAuG,CACvM,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,wBAAwB,CAAC;QACrC,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;CACF"}
+{"version":3,"file":"errors.js","sourceRoot":"","sources":["../src/errors.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,MAAM,OAAgB,UAAW,SAAQ,KAAK;CAM7C;AAuBD;;;;;;;;;;;GAWG;AACH,MAAM,OAAO,YAAa,SAAQ,UAAU;IACjC,IAAI,GAAG,oBAAoB,CAAC;IAC5B,IAAI,CAAS;IACb,MAAM,CAAS;IACf,QAAQ,CAAS;IAE1B,YAAY,OAAe,EAAE,IAAsB;QACjD,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,cAAc,CAAC;QAC3B,IAAI,CAAC,IAAI,GAAG,IAAI,CAAC,IAAI,CAAC;QACtB,IAAI,CAAC,MAAM,GAAG,IAAI,CAAC,MAAM,CAAC;QAC1B,IAAI,CAAC,QAAQ,GAAG,IAAI,CAAC,QAAQ,CAAC;IAChC,CAAC;CACF;AAED;;;;;;;GAOG;AACH,MAAM,OAAO,qBAAsB,SAAQ,UAAU;IAC1C,IAAI,GAAG,wBAAwB,CAAC;IACzC,0EAA0E;IACjE,OAAO,CAAS;IAEzB,YAAY,OAAe,EAAE,iBAA0C;QACrE,KAAK,CACH,uCAAuC,OAAO,8BAA8B,iBAAiB,CAAC,IAAI,CAAC,IAAI,CAAC,EAAE,CAC3G,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,uBAAuB,CAAC;QACpC,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;IACzB,CAAC;CACF;AAED;;;;;;;;;GASG;AACH,MAAM,OAAO,eAAgB,SAAQ,UAAU;IACpC,IAAI,GAAG,iBAAiB,CAAC;IAElC,YAAY,OAAe;QACzB,KAAK,CAAC,OAAO,CAAC,CAAC;QACf,IAAI,CAAC,IAAI,GAAG,iBAAiB,CAAC;IAChC,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;GAmBG;AACH,MAAM,OAAO,sBAAuB,SAAQ,UAAU;IAC3C,IAAI,GAAG,0BAA0B,CAAC;IAC3C,mHAAmH;IAC1G,QAAQ,CAAS;IAE1B,YAAY,QAAgB;QAC1B,KAAK,CACH,+EAA+E,MAAM,CAAC,QAAQ,CAAC,uGAAuG,CACvM,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,wBAAwB,CAAC;QACrC,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;IAC3B,CAAC;CACF;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,MAAM,OAAO,oBAAqB,SAAQ,UAAU;IACzC,IAAI,GAAG,wBAAwB,CAAC;IACzC,qHAAqH;IAC5G,QAAQ,CAAS;IAC1B;;;;OAIG;IACM,cAAc,CAAS;IAEhC,YAAY,QAAgB,EAAE,cAAsB;QAClD,KAAK,CACH,0DAA0D,MAAM,CAAC,cAAc,CAAC,sDAAsD,MAAM,CAAC,QAAQ,CAAC,kKAAkK,CACzT,CAAC;QACF,IAAI,CAAC,IAAI,GAAG,sBAAsB,CAAC;QACnC,IAAI,CAAC,QAAQ,GAAG,QAAQ,CAAC;QACzB,IAAI,CAAC,cAAc,GAAG,cAAc,CAAC;IACvC,CAAC;CACF;AAED;;;;;;;;;;GAUG;AACH,MAAM,OAAO,gCAAiC,SAAQ,UAAU;IACrD,IAAI,GAAG,qCAAqC,CAAC;IAEtD,YAAY,OAAe;QACzB,KAAK,CAAC,qDAAqD,OAAO,EAAE,CAAC,CAAC;QACtE,IAAI,CAAC,IAAI,GAAG,kCAAkC,CAAC;IACjD,CAAC;CACF"}

package/dist/index.d.ts

@@ -1,5 +1,5 @@
 export { parseSync } from './parse.js';
-export { ShAnalyzeMaxDepthError, ShBridgeError, ShBridgeInternalError, ShInvalidDialectError, ShParseError, } from './errors.js';
+export { ShAnalyzeInvalidWrapperSpecError, ShAnalyzeMaxDepthError, ShAstError, ShInternalError, ShInvalidDialectError, ShParseError, ShParseMaxDepthError, } from './errors.js';
 export type { ShParseErrorInfo } from './errors.js';
 export type { ParseOptions, Position, ShellDialect, ShFile, ShNode } from './types.js';
 export { visitorKeys } from './visitor-keys.js';

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,EACL,sBAAsB,EACtB,aAAa,EACb,qBAAqB,EACrB,qBAAqB,EACrB,YAAY,GACb,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,YAAY,EAAE,YAAY,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AACvF,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC;;;;;;;;;GASG;AACH,YAAY,KAAK,OAAO,MAAM,4BAA4B,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,EACL,gCAAgC,EAChC,sBAAsB,EACtB,UAAU,EACV,eAAe,EACf,qBAAqB,EACrB,YAAY,EACZ,oBAAoB,GACrB,MAAM,aAAa,CAAC;AACrB,YAAY,EAAE,gBAAgB,EAAE,MAAM,aAAa,CAAC;AACpD,YAAY,EAAE,YAAY,EAAE,QAAQ,EAAE,YAAY,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,YAAY,CAAC;AACvF,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC;AAEjC;;;;;;;;;GASG;AACH,YAAY,KAAK,OAAO,MAAM,4BAA4B,CAAC"}

package/dist/index.js

@@ -1,5 +1,5 @@
 export { parseSync } from './parse.js';
-export { ShAnalyzeMaxDepthError, ShBridgeError, ShBridgeInternalError, ShInvalidDialectError, ShParseError, } from './errors.js';
+export { ShAnalyzeInvalidWrapperSpecError, ShAnalyzeMaxDepthError, ShAstError, ShInternalError, ShInvalidDialectError, ShParseError, ShParseMaxDepthError, } from './errors.js';
 export { visitorKeys } from './visitor-keys.js';
 export { walk } from './walk.js';
 //# sourceMappingURL=index.js.map

package/dist/index.js.map

@@ -1 +1 @@
-{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,EACL,sBAAsB,EACtB,aAAa,EACb,qBAAqB,EACrB,qBAAqB,EACrB,YAAY,GACb,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC"}
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,YAAY,CAAC;AACvC,OAAO,EACL,gCAAgC,EAChC,sBAAsB,EACtB,UAAU,EACV,eAAe,EACf,qBAAqB,EACrB,YAAY,EACZ,oBAAoB,GACrB,MAAM,aAAa,CAAC;AAGrB,OAAO,EAAE,WAAW,EAAE,MAAM,mBAAmB,CAAC;AAChD,OAAO,EAAE,IAAI,EAAE,MAAM,WAAW,CAAC"}

package/dist/parse-depth-guard.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Throws {@link ShParseMaxDepthError} if `text`'s conservatively-estimated
+ * structural nesting depth (see {@link estimateMaxNestingDepth}) exceeds
+ * {@link MAX_PARSE_NESTING_DEPTH} — called by {@link parseSync} *before* it
+ * ever hands `text` to the WASM shim, so pathological input never reaches
+ * (and never risks crashing) the shared WASM instance in the first place.
+ *
+ * @internal
+ */
+export declare function assertParseDepthWithinLimit(text: string): void;
+//# sourceMappingURL=parse-depth-guard.d.ts.map

package/dist/parse-depth-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"parse-depth-guard.d.ts","sourceRoot":"","sources":["../src/parse-depth-guard.ts"],"names":[],"mappings":"AAgnBA;;;;;;;;GAQG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAK9D"}