@kensio/yulin 1.10.0 → 1.10.2

package/dist/config/lint/cff-js2-restriction.d.ts

@@ -0,0 +1,82 @@
+/**
+ * What the CloudFront Functions JS2 runtime will not run, as syntax selectors.
+ *
+ * JS2 is compliant with ECMAScript 5.1 and adds a named subset of ES 6 to 12,
+ * so a Function that uses something outside that subset fails when it is
+ * published, a long way from where it was written. Each entry names a
+ * construct the runtime has no support for and says what to write instead, so
+ * the refusal arrives in the editor.
+ *
+ * Every entry is drawn from the runtime's own feature list, which is an
+ * allow-list: anything the documentation does not name is unsupported. Nothing
+ * here is house style. A restriction on syntax JS2 accepts would send a reader
+ * away from code that works, which is worse than no lint rule at all.
+ *
+ * https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/functions-javascript-runtime-20.html
+ *
+ * The selector syntax is the one both ESLint and Oxlint accept, which is what
+ * lets a single rule module serve either linter.
+ */
+export declare const cffJs2SyntaxRestrictions: {
+    readonly "no-import": {
+        readonly selector: "ImportDeclaration";
+        readonly message: "CloudFront Functions must be self-contained and should not use import syntax.";
+    };
+    readonly "only-handler-export": {
+        readonly selector: "ExportNamedDeclaration:not([declaration.type='FunctionDeclaration'][declaration.id.name='handler']), ExportDefaultDeclaration, ExportAllDeclaration";
+        readonly message: "CloudFront Function files may only export the handler as `export function handler(...)`.";
+    };
+    readonly "only-built-in-require": {
+        readonly selector: "CallExpression[callee.name='require']:not(:has(Literal[value='querystring'])):not(:has(Literal[value='crypto'])):not(:has(Literal[value='buffer']))";
+        readonly message: "CloudFront Functions can only require the built-in `querystring`, `crypto` and `buffer` modules. Everything else must be inlined.";
+    };
+    readonly "no-class": {
+        readonly selector: "ClassDeclaration, ClassExpression";
+        readonly message: "CloudFront Functions JS2 does not support class syntax. Use a constructor function or a plain object instead.";
+    };
+    readonly "no-generator": {
+        readonly selector: "YieldExpression, FunctionDeclaration[generator=true], FunctionExpression[generator=true]";
+        readonly message: "CloudFront Functions JS2 does not support generators.";
+    };
+    readonly "no-destructuring": {
+        readonly selector: "ObjectPattern, ArrayPattern";
+        readonly message: "CloudFront Functions JS2 does not support destructuring. Read the properties one at a time instead.";
+    };
+    readonly "no-spread": {
+        readonly selector: "SpreadElement";
+        readonly message: "CloudFront Functions JS2 does not support spread syntax. Rest parameters are supported, so `function f(...args)` is fine, but `[...list]` is not.";
+    };
+    readonly "no-for-of": {
+        readonly selector: "ForOfStatement";
+        readonly message: "CloudFront Functions JS2 does not support for...of. Use an index-based loop or for...in instead.";
+    };
+};
+/**
+ * Globals a CloudFront Function cannot reach, and why each one is absent.
+ *
+ * These read as ordinary JavaScript and fail only at the edge, which is the
+ * worst place to find out. The reason matters as much as the refusal: `fetch`
+ * is missing because the runtime has no network, and `setTimeout` because it
+ * has no event loop, and those two dead ends want different rewrites.
+ *
+ * `Promise` and `Buffer` are deliberately absent from this list. Both are
+ * supported in runtime 2.0, and an earlier version of this config refused them.
+ */
+export declare const cffJs2UnavailableGlobals: {
+    readonly fetch: "CloudFront Functions cannot make network requests.";
+    readonly XMLHttpRequest: "CloudFront Functions cannot make network requests.";
+    readonly WebSocket: "CloudFront Functions cannot open network connections.";
+    readonly process: "CloudFront Functions do not have access to Node.js process APIs.";
+    readonly setTimeout: "CloudFront Functions do not support timers, and must run to completion synchronously.";
+    readonly setInterval: "CloudFront Functions do not support timers, and must run to completion synchronously.";
+    readonly setImmediate: "CloudFront Functions do not support timers, and must run to completion synchronously.";
+    readonly clearTimeout: "CloudFront Functions do not support timers, so there is nothing to clear.";
+};
+/**
+ * The name of the rule that reports an unavailable global.
+ *
+ * It is kept apart from the syntax restrictions because it resolves names
+ * through scope rather than matching a selector.
+ */
+export declare const cffJs2UnavailableGlobalRuleName = "no-unavailable-global";
+//# sourceMappingURL=cff-js2-restriction.d.ts.map

package/dist/config/lint/cff-js2-restriction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cff-js2-restriction.d.ts","sourceRoot":"","sources":["../../../src/config/lint/cff-js2-restriction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,wBAAwB;;iBAEjC,QAAQ,EAAE,mBAAmB;iBAC7B,OAAO,EACL,+EAA+E;;;iBAGjF,QAAQ,EACN,qJAAqJ;iBACvJ,OAAO,EACL,0FAA0F;;;iBAG5F,QAAQ,EACN,qJAAqJ;iBACvJ,OAAO,EACL,mIAAmI;;;iBAGrI,QAAQ,EAAE,mCAAmC;iBAC7C,OAAO,EACL,+GAA+G;;;iBAGjH,QAAQ,EACN,0FAA0F;iBAC5F,OAAO,EAAE,uDAAuD;;;iBAGhE,QAAQ,EAAE,6BAA6B;iBACvC,OAAO,EACL,qGAAqG;;;iBAMvG,QAAQ,EAAE,eAAe;iBACzB,OAAO,EACL,mJAAmJ;;;iBAGrJ,QAAQ,EAAE,gBAAgB;iBAC1B,OAAO,EACL,kGAAkG;;CAIvG,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,wBAAwB;oBAC5B,oDAAoD;6BAC3C,oDAAoD;wBACzD,uDAAuD;sBACzD,kEAAkE;yBAEzE,uFAAuF;0BAEvF,uFAAuF;2BAEvF,uFAAuF;2BAEvF,2EAA2E;CAC1B,CAAC;AAEtD;;;;;GAKG;AACH,eAAO,MAAM,+BAA+B,0BAA0B,CAAC"}

package/dist/config/lint/cff-js2-restriction.js

@@ -0,0 +1,85 @@
+/**
+ * What the CloudFront Functions JS2 runtime will not run, as syntax selectors.
+ *
+ * JS2 is compliant with ECMAScript 5.1 and adds a named subset of ES 6 to 12,
+ * so a Function that uses something outside that subset fails when it is
+ * published, a long way from where it was written. Each entry names a
+ * construct the runtime has no support for and says what to write instead, so
+ * the refusal arrives in the editor.
+ *
+ * Every entry is drawn from the runtime's own feature list, which is an
+ * allow-list: anything the documentation does not name is unsupported. Nothing
+ * here is house style. A restriction on syntax JS2 accepts would send a reader
+ * away from code that works, which is worse than no lint rule at all.
+ *
+ * https://docs.aws.amazon.com/AmazonCloudFront/latest/DeveloperGuide/functions-javascript-runtime-20.html
+ *
+ * The selector syntax is the one both ESLint and Oxlint accept, which is what
+ * lets a single rule module serve either linter.
+ */
+export const cffJs2SyntaxRestrictions = {
+    "no-import": {
+        selector: "ImportDeclaration",
+        message: "CloudFront Functions must be self-contained and should not use import syntax.",
+    },
+    "only-handler-export": {
+        selector: "ExportNamedDeclaration:not([declaration.type='FunctionDeclaration'][declaration.id.name='handler']), ExportDefaultDeclaration, ExportAllDeclaration",
+        message: "CloudFront Function files may only export the handler as `export function handler(...)`.",
+    },
+    "only-built-in-require": {
+        selector: "CallExpression[callee.name='require']:not(:has(Literal[value='querystring'])):not(:has(Literal[value='crypto'])):not(:has(Literal[value='buffer']))",
+        message: "CloudFront Functions can only require the built-in `querystring`, `crypto` and `buffer` modules. Everything else must be inlined.",
+    },
+    "no-class": {
+        selector: "ClassDeclaration, ClassExpression",
+        message: "CloudFront Functions JS2 does not support class syntax. Use a constructor function or a plain object instead.",
+    },
+    "no-generator": {
+        selector: "YieldExpression, FunctionDeclaration[generator=true], FunctionExpression[generator=true]",
+        message: "CloudFront Functions JS2 does not support generators.",
+    },
+    "no-destructuring": {
+        selector: "ObjectPattern, ArrayPattern",
+        message: "CloudFront Functions JS2 does not support destructuring. Read the properties one at a time instead.",
+    },
+    "no-spread": {
+        // Rest parameters are a separate ES 6 feature that JS2 does name as
+        // supported, and they share the `RestElement` node, so only spread is
+        // matched here.
+        selector: "SpreadElement",
+        message: "CloudFront Functions JS2 does not support spread syntax. Rest parameters are supported, so `function f(...args)` is fine, but `[...list]` is not.",
+    },
+    "no-for-of": {
+        selector: "ForOfStatement",
+        message: "CloudFront Functions JS2 does not support for...of. Use an index-based loop or for...in instead.",
+    },
+};
+/**
+ * Globals a CloudFront Function cannot reach, and why each one is absent.
+ *
+ * These read as ordinary JavaScript and fail only at the edge, which is the
+ * worst place to find out. The reason matters as much as the refusal: `fetch`
+ * is missing because the runtime has no network, and `setTimeout` because it
+ * has no event loop, and those two dead ends want different rewrites.
+ *
+ * `Promise` and `Buffer` are deliberately absent from this list. Both are
+ * supported in runtime 2.0, and an earlier version of this config refused them.
+ */
+export const cffJs2UnavailableGlobals = {
+    fetch: "CloudFront Functions cannot make network requests.",
+    XMLHttpRequest: "CloudFront Functions cannot make network requests.",
+    WebSocket: "CloudFront Functions cannot open network connections.",
+    process: "CloudFront Functions do not have access to Node.js process APIs.",
+    setTimeout: "CloudFront Functions do not support timers, and must run to completion synchronously.",
+    setInterval: "CloudFront Functions do not support timers, and must run to completion synchronously.",
+    setImmediate: "CloudFront Functions do not support timers, and must run to completion synchronously.",
+    clearTimeout: "CloudFront Functions do not support timers, so there is nothing to clear.",
+};
+/**
+ * The name of the rule that reports an unavailable global.
+ *
+ * It is kept apart from the syntax restrictions because it resolves names
+ * through scope rather than matching a selector.
+ */
+export const cffJs2UnavailableGlobalRuleName = "no-unavailable-global";
+//# sourceMappingURL=cff-js2-restriction.js.map

package/dist/config/lint/cff-js2-restriction.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cff-js2-restriction.js","sourceRoot":"","sources":["../../../src/config/lint/cff-js2-restriction.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACtC,WAAW,EAAE;QACX,QAAQ,EAAE,mBAAmB;QAC7B,OAAO,EACL,+EAA+E;KAClF;IACD,qBAAqB,EAAE;QACrB,QAAQ,EACN,qJAAqJ;QACvJ,OAAO,EACL,0FAA0F;KAC7F;IACD,uBAAuB,EAAE;QACvB,QAAQ,EACN,qJAAqJ;QACvJ,OAAO,EACL,mIAAmI;KACtI;IACD,UAAU,EAAE;QACV,QAAQ,EAAE,mCAAmC;QAC7C,OAAO,EACL,+GAA+G;KAClH;IACD,cAAc,EAAE;QACd,QAAQ,EACN,0FAA0F;QAC5F,OAAO,EAAE,uDAAuD;KACjE;IACD,kBAAkB,EAAE;QAClB,QAAQ,EAAE,6BAA6B;QACvC,OAAO,EACL,qGAAqG;KACxG;IACD,WAAW,EAAE;QACX,oEAAoE;QACpE,sEAAsE;QACtE,gBAAgB;QAChB,QAAQ,EAAE,eAAe;QACzB,OAAO,EACL,mJAAmJ;KACtJ;IACD,WAAW,EAAE;QACX,QAAQ,EAAE,gBAAgB;QAC1B,OAAO,EACL,kGAAkG;KACrG;CAGF,CAAC;AAEF;;;;;;;;;;GAUG;AACH,MAAM,CAAC,MAAM,wBAAwB,GAAG;IACtC,KAAK,EAAE,oDAAoD;IAC3D,cAAc,EAAE,oDAAoD;IACpE,SAAS,EAAE,uDAAuD;IAClE,OAAO,EAAE,kEAAkE;IAC3E,UAAU,EACR,uFAAuF;IACzF,WAAW,EACT,uFAAuF;IACzF,YAAY,EACV,uFAAuF;IACzF,YAAY,EACV,2EAA2E;CAC1B,CAAC;AAEtD;;;;;GAKG;AACH,MAAM,CAAC,MAAM,+BAA+B,GAAG,uBAAuB,CAAC"}

package/dist/config/lint/cff-js2-unavailable-global.rule.d.ts

@@ -0,0 +1,10 @@
+import type { LintRule } from "./lint-plugin.type.js";
+/**
+ * Reports a name the CloudFront Functions runtime does not provide.
+ *
+ * Names are resolved through scope rather than matched as text, so a local
+ * variable called `fetch` and a property called `event.fetch` are both left
+ * alone: what is reported is a reference that would reach a global.
+ */
+export declare function cffJs2UnavailableGlobalRule(): LintRule;
+//# sourceMappingURL=cff-js2-unavailable-global.rule.d.ts.map

package/dist/config/lint/cff-js2-unavailable-global.rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cff-js2-unavailable-global.rule.d.ts","sourceRoot":"","sources":["../../../src/config/lint/cff-js2-unavailable-global.rule.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAEV,QAAQ,EAGT,MAAM,uBAAuB,CAAC;AAY/B;;;;;;GAMG;AACH,wBAAgB,2BAA2B,IAAI,QAAQ,CA4BtD"}

package/dist/config/lint/cff-js2-unavailable-global.rule.js

@@ -0,0 +1,42 @@
+import { cffJs2UnavailableGlobals } from "./cff-js2-restriction.js";
+/**
+ * Scope is only complete once the whole file has been walked, so the globals a
+ * file reaches for are counted on the way out of it rather than on the way in.
+ */
+const programExitSelector = "Program:exit";
+const reasons = new Map(Object.entries(cffJs2UnavailableGlobals));
+/**
+ * Reports a name the CloudFront Functions runtime does not provide.
+ *
+ * Names are resolved through scope rather than matched as text, so a local
+ * variable called `fetch` and a property called `event.fetch` are both left
+ * alone: what is reported is a reference that would reach a global.
+ */
+export function cffJs2UnavailableGlobalRule() {
+    return {
+        meta: {
+            type: "problem",
+            schema: [],
+            messages: { unsupported: "{{why}}" },
+        },
+        create: (context) => ({
+            [programExitSelector]: (node) => {
+                const scope = context.sourceCode.getScope(node);
+                for (const reference of [
+                    ...scope.through,
+                    ...scope.variables.flatMap((variable) => variable.references),
+                ]) {
+                    const why = reasons.get(reference.identifier.name);
+                    if (why !== undefined) {
+                        context.report({
+                            node: reference.identifier,
+                            messageId: "unsupported",
+                            data: { why },
+                        });
+                    }
+                }
+            },
+        }),
+    };
+}
+//# sourceMappingURL=cff-js2-unavailable-global.rule.js.map

package/dist/config/lint/cff-js2-unavailable-global.rule.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cff-js2-unavailable-global.rule.js","sourceRoot":"","sources":["../../../src/config/lint/cff-js2-unavailable-global.rule.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,wBAAwB,EAAE,MAAM,0BAA0B,CAAC;AAQpE;;;GAGG;AACH,MAAM,mBAAmB,GAAG,cAAc,CAAC;AAE3C,MAAM,OAAO,GAAG,IAAI,GAAG,CACrB,MAAM,CAAC,OAAO,CAAC,wBAAwB,CAAC,CACzC,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,UAAU,2BAA2B;IACzC,OAAO;QACL,IAAI,EAAE;YACJ,IAAI,EAAE,SAAS;YACf,MAAM,EAAE,EAAE;YACV,QAAQ,EAAE,EAAE,WAAW,EAAE,SAAS,EAAE;SACrC;QACD,MAAM,EAAE,CAAC,OAAwB,EAAe,EAAE,CAAC,CAAC;YAClD,CAAC,mBAAmB,CAAC,EAAE,CAAC,IAAc,EAAQ,EAAE;gBAC9C,MAAM,KAAK,GAAG,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,IAAI,CAAC,CAAC;gBAEhD,KAAK,MAAM,SAAS,IAAI;oBACtB,GAAG,KAAK,CAAC,OAAO;oBAChB,GAAG,KAAK,CAAC,SAAS,CAAC,OAAO,CAAC,CAAC,QAAQ,EAAE,EAAE,CAAC,QAAQ,CAAC,UAAU,CAAC;iBAC9D,EAAE,CAAC;oBACF,MAAM,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,CAAC;oBAEnD,IAAI,GAAG,KAAK,SAAS,EAAE,CAAC;wBACtB,OAAO,CAAC,MAAM,CAAC;4BACb,IAAI,EAAE,SAAS,CAAC,UAAU;4BAC1B,SAAS,EAAE,aAAa;4BACxB,IAAI,EAAE,EAAE,GAAG,EAAE;yBACd,CAAC,CAAC;oBACL,CAAC;gBACH,CAAC;YACH,CAAC;SACF,CAAC;KACH,CAAC;AACJ,CAAC"}

package/dist/config/lint/index.d.ts

@@ -0,0 +1,6 @@
+export { cffJs2LintPlugin, cffJs2PluginName } from "./cff-js2-lint-plugin.js";
+export { cffJs2LintPluginRules, cffJs2LintRules, type LintRuleSetting, } from "./cff-js2-lint-rules.js";
+export { cffJs2SyntaxRestrictions, cffJs2UnavailableGlobalRuleName, cffJs2UnavailableGlobals, } from "./cff-js2-restriction.js";
+export { cffJs2UnavailableGlobalRule } from "./cff-js2-unavailable-global.rule.js";
+export type { LintIdentifierNode, LintNode, LintPlugin, LintReference, LintRule, LintRuleContext, LintScope, LintVariable, LintVisitor, } from "./lint-plugin.type.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/config/lint/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/config/lint/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAC9E,OAAO,EACL,qBAAqB,EACrB,eAAe,EACf,KAAK,eAAe,GACrB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,wBAAwB,EACxB,+BAA+B,EAC/B,wBAAwB,GACzB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC;AACnF,YAAY,EACV,kBAAkB,EAClB,QAAQ,EACR,UAAU,EACV,aAAa,EACb,QAAQ,EACR,eAAe,EACf,SAAS,EACT,YAAY,EACZ,WAAW,GACZ,MAAM,uBAAuB,CAAC"}

package/dist/config/lint/index.js

@@ -0,0 +1,5 @@
+export { cffJs2LintPlugin, cffJs2PluginName } from "./cff-js2-lint-plugin.js";
+export { cffJs2LintPluginRules, cffJs2LintRules, } from "./cff-js2-lint-rules.js";
+export { cffJs2SyntaxRestrictions, cffJs2UnavailableGlobalRuleName, cffJs2UnavailableGlobals, } from "./cff-js2-restriction.js";
+export { cffJs2UnavailableGlobalRule } from "./cff-js2-unavailable-global.rule.js";
+//# sourceMappingURL=index.js.map

package/dist/config/lint/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/config/lint/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,gBAAgB,EAAE,MAAM,0BAA0B,CAAC;AAC9E,OAAO,EACL,qBAAqB,EACrB,eAAe,GAEhB,MAAM,yBAAyB,CAAC;AACjC,OAAO,EACL,wBAAwB,EACxB,+BAA+B,EAC/B,wBAAwB,GACzB,MAAM,0BAA0B,CAAC;AAClC,OAAO,EAAE,2BAA2B,EAAE,MAAM,sCAAsC,CAAC"}

package/dist/config/lint/lint-plugin.type.d.ts

@@ -0,0 +1,82 @@
+/**
+ * The slice of a linter's rule API that these plugins actually touch.
+ *
+ * ESLint and Oxlint both load the same plugin object, so typing it against
+ * either one's published types would tie the plugin to a linter it is meant to
+ * outlive. These declarations describe only what the rules here call, which is
+ * narrow enough to stay true of both and leaves the plugin with no dependency
+ * of its own.
+ */
+/**
+ * A node in the syntax tree, identified by the type name a selector matches.
+ */
+export interface LintNode {
+    readonly type: string;
+}
+/**
+ * An identifier node, which is the only node kind read by name here.
+ */
+export interface LintIdentifierNode extends LintNode {
+    readonly name: string;
+}
+/**
+ * One place a binding is read or written.
+ */
+export interface LintReference {
+    readonly identifier: LintIdentifierNode;
+}
+/**
+ * A resolved binding together with every reference to it.
+ */
+export interface LintVariable {
+    readonly references: readonly LintReference[];
+}
+/**
+ * A lexical scope, as the linter resolved it.
+ *
+ * References to a name nothing declares land in `through` rather than in
+ * `variables`, so a rule looking for globals has to read both: which of the two
+ * a name falls into depends on whether the linter was told that global exists.
+ */
+export interface LintScope {
+    readonly through: readonly LintReference[];
+    readonly variables: readonly LintVariable[];
+}
+/**
+ * What a rule is handed for the file it is looking at.
+ */
+export interface LintRuleContext {
+    readonly sourceCode: {
+        getScope(node: LintNode): LintScope;
+    };
+    report(descriptor: {
+        node: LintNode;
+        messageId: string;
+        data?: Readonly<Record<string, string>>;
+    }): void;
+}
+/**
+ * The handlers a rule registers, keyed by the selector that triggers them.
+ */
+export type LintVisitor = Record<string, (node: never) => void>;
+/**
+ * One rule, in the shape both linters expect to load.
+ */
+export interface LintRule {
+    readonly meta: {
+        readonly type: "problem";
+        readonly schema: readonly [];
+        readonly messages: Readonly<Record<string, string>>;
+    };
+    create(context: LintRuleContext): LintVisitor;
+}
+/**
+ * A plugin, in the shape both linters expect to load.
+ */
+export interface LintPlugin {
+    readonly meta: {
+        readonly name: string;
+    };
+    readonly rules: Readonly<Record<string, LintRule>>;
+}
+//# sourceMappingURL=lint-plugin.type.d.ts.map

package/dist/config/lint/lint-plugin.type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"lint-plugin.type.d.ts","sourceRoot":"","sources":["../../../src/config/lint/lint-plugin.type.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG;AAEH;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,kBAAmB,SAAQ,QAAQ;IAClD,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;CACvB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC5B,QAAQ,CAAC,UAAU,EAAE,kBAAkB,CAAC;CACzC;AAED;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,UAAU,EAAE,SAAS,aAAa,EAAE,CAAC;CAC/C;AAED;;;;;;GAMG;AACH,MAAM,WAAW,SAAS;IACxB,QAAQ,CAAC,OAAO,EAAE,SAAS,aAAa,EAAE,CAAC;IAC3C,QAAQ,CAAC,SAAS,EAAE,SAAS,YAAY,EAAE,CAAC;CAC7C;AAED;;GAEG;AACH,MAAM,WAAW,eAAe;IAC9B,QAAQ,CAAC,UAAU,EAAE;QACnB,QAAQ,CAAC,IAAI,EAAE,QAAQ,GAAG,SAAS,CAAC;KACrC,CAAC;IACF,MAAM,CAAC,UAAU,EAAE;QACjB,IAAI,EAAE,QAAQ,CAAC;QACf,SAAS,EAAE,MAAM,CAAC;QAClB,IAAI,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;KACzC,GAAG,IAAI,CAAC;CACV;AAED;;GAEG;AACH,MAAM,MAAM,WAAW,GAAG,MAAM,CAAC,MAAM,EAAE,CAAC,IAAI,EAAE,KAAK,KAAK,IAAI,CAAC,CAAC;AAEhE;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,QAAQ,CAAC,IAAI,EAAE;QACb,QAAQ,CAAC,IAAI,EAAE,SAAS,CAAC;QACzB,QAAQ,CAAC,MAAM,EAAE,SAAS,EAAE,CAAC;QAC7B,QAAQ,CAAC,QAAQ,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAC;KACrD,CAAC;IACF,MAAM,CAAC,OAAO,EAAE,eAAe,GAAG,WAAW,CAAC;CAC/C;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,QAAQ,CAAC,IAAI,EAAE;QAAE,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAA;KAAE,CAAC;IACzC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAC,CAAC;CACpD"}

package/dist/config/lint/lint-plugin.type.js

@@ -0,0 +1,11 @@
+/**
+ * The slice of a linter's rule API that these plugins actually touch.
+ *
+ * ESLint and Oxlint both load the same plugin object, so typing it against
+ * either one's published types would tie the plugin to a linter it is meant to
+ * outlive. These declarations describe only what the rules here call, which is
+ * narrow enough to stay true of both and leaves the plugin with no dependency
+ * of its own.
+ */
+export {};
+//# sourceMappingURL=lint-plugin.type.js.map

package/dist/config/lint/lint-plugin.type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"lint-plugin.type.js","sourceRoot":"","sources":["../../../src/config/lint/lint-plugin.type.ts"],"names":[],"mappings":"AAAA;;;;;;;;GAQG"}

package/dist/config/lint/repo-lint-plugin.d.ts

@@ -0,0 +1,68 @@
+import type { LintPlugin } from "./lint-plugin.type.js";
+/**
+ * This repository's own lint restrictions, as a plugin Oxlint can load.
+ *
+ * Two constraints shape this file, and both are worth knowing before editing
+ * it.
+ *
+ * It is one file rather than the three the CloudFront Functions plugin next
+ * door is split across. Oxlint imports a JS plugin through Node, and `.ts` gets
+ * there on Node's own type stripping rather than a loader — `tsx` breaks
+ * `eslint-plugin-no-secrets` when it is in the path, and `jiti` hands Oxlint a
+ * module wrapper instead of the plugin. Type stripping does not rewrite a
+ * `./x.js` specifier to `./x.ts`, so a relative *value* import here would not
+ * resolve at lint time. Type-only imports are erased before Node sees them,
+ * which is why the ones above are fine.
+ *
+ * The restrictions are named rules rather than a `no-restricted-syntax` block.
+ * Oxlint has no equivalent of that rule, but the shape is the better one
+ * regardless: a report says which restriction fired instead of quoting a
+ * selector, one can be switched off without restating the others, and two
+ * configs setting it cannot silently replace each other. That last one is not
+ * hypothetical — under ESLint, `@kensio/smartass` setting `no-restricted-syntax`
+ * turned this repository's own restrictions off for 265 commits.
+ *
+ * Only this repository's own restrictions live here. The assertion advice from
+ * `@kensio/smartass` used to as well, lifted out of the `no-restricted-syntax`
+ * block in the config it published because there was nothing else to load.
+ * Since 1.37.0 it publishes a real Oxlint plugin, so `.oxlintrc.json` loads
+ * `smartass/prefer-specific-assertions` from the package instead.
+ */
+/**
+ * One thing this repository will not have written in it.
+ */
+export interface RepoSyntaxRestriction {
+    readonly selector: string;
+    readonly message: string;
+}
+/**
+ * The name Oxlint reports these rules under.
+ */
+export declare const repoLintPluginName = "yulin";
+/**
+ * The restrictions this repository sets on itself.
+ */
+export declare const repoSyntaxRestrictions: {
+    "assert-defined-guard": {
+        selector: string;
+        message: string;
+    };
+    "assert-not-null-guard": {
+        selector: string;
+        message: string;
+    };
+    "no-reused-props": {
+        selector: string;
+        message: string;
+    };
+};
+/**
+ * The plugin `.oxlintrc.json` names as `yulin`.
+ *
+ * It is not published. `dist/` carries it because everything under `src/`
+ * does, but nothing in `exports` points at it: these are house rules for
+ * yulin, not advice for anyone installing yulin.
+ */
+export declare const repoLintPlugin: LintPlugin;
+export default repoLintPlugin;
+//# sourceMappingURL=repo-lint-plugin.d.ts.map

package/dist/config/lint/repo-lint-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"repo-lint-plugin.d.ts","sourceRoot":"","sources":["../../../src/config/lint/repo-lint-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,UAAU,EAIX,MAAM,uBAAuB,CAAC;AAE/B;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH;;GAEG;AACH,MAAM,WAAW,qBAAqB;IACpC,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;CAC1B;AAED;;GAEG;AACH,eAAO,MAAM,kBAAkB,UAAU,CAAC;AAE1C;;GAEG;AACH,eAAO,MAAM,sBAAsB;;QAE/B,QAAQ;QAER,OAAO;;;QAIP,QAAQ;QAER,OAAO;;;QAIP,QAAQ;QAER,OAAO;;CAGgD,CAAC;AAqC5D;;;;;;GAMG;AACH,eAAO,MAAM,cAAc,EAAE,UAG5B,CAAC;eAEa,cAAc"}

package/dist/config/lint/repo-lint-plugin.js

@@ -0,0 +1,64 @@
+/**
+ * The name Oxlint reports these rules under.
+ */
+export const repoLintPluginName = "yulin";
+/**
+ * The restrictions this repository sets on itself.
+ */
+export const repoSyntaxRestrictions = {
+    "assert-defined-guard": {
+        selector: "IfStatement[test.type='BinaryExpression'][test.operator='===']:matches([test.left.type='Identifier'][test.left.name='undefined'], [test.right.type='Identifier'][test.right.name='undefined']):has(ThrowStatement[argument.type='NewExpression'][argument.callee.name='Error'])",
+        message: "Use `assertDefined(value, description)` instead of throwing `Error` from an `undefined` guard.",
+    },
+    "assert-not-null-guard": {
+        selector: "IfStatement[test.type='BinaryExpression'][test.operator='===']:matches([test.left.type='Literal'][test.left.value=null], [test.right.type='Literal'][test.right.value=null]):has(ThrowStatement[argument.type='NewExpression'][argument.callee.name='Error'])",
+        message: "Use `assertNotNull(value, description)` instead of throwing `Error` from a `null` guard.",
+    },
+    "no-reused-props": {
+        selector: "MemberExpression[object.type='ThisExpression'][property.type='Identifier'][property.name='props']",
+        message: "Do not reuse `this.props`. Destructure constructor props into class members instead.",
+    },
+};
+/**
+ * The one message id every rule here reports under.
+ *
+ * Each restriction is its own rule, so a rule never has a second message to
+ * tell apart from this one.
+ */
+const messageId = "restriction";
+/**
+ * Builds the rule that reports one restriction.
+ */
+function restrictionRule(restriction) {
+    return {
+        meta: {
+            type: "problem",
+            schema: [],
+            messages: { [messageId]: restriction.message },
+        },
+        create: (context) => ({
+            [restriction.selector]: (node) => {
+                context.report({ node, messageId });
+            },
+        }),
+    };
+}
+function buildRules() {
+    return Object.fromEntries(Object.entries(repoSyntaxRestrictions).map(([name, restriction]) => [
+        name,
+        restrictionRule(restriction),
+    ]));
+}
+/**
+ * The plugin `.oxlintrc.json` names as `yulin`.
+ *
+ * It is not published. `dist/` carries it because everything under `src/`
+ * does, but nothing in `exports` points at it: these are house rules for
+ * yulin, not advice for anyone installing yulin.
+ */
+export const repoLintPlugin = {
+    meta: { name: repoLintPluginName },
+    rules: buildRules(),
+};
+export default repoLintPlugin;
+//# sourceMappingURL=repo-lint-plugin.js.map

package/dist/config/lint/repo-lint-plugin.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"repo-lint-plugin.js","sourceRoot":"","sources":["../../../src/config/lint/repo-lint-plugin.ts"],"names":[],"mappings":"AA8CA;;GAEG;AACH,MAAM,CAAC,MAAM,kBAAkB,GAAG,OAAO,CAAC;AAE1C;;GAEG;AACH,MAAM,CAAC,MAAM,sBAAsB,GAAG;IACpC,sBAAsB,EAAE;QACtB,QAAQ,EACN,iRAAiR;QACnR,OAAO,EACL,gGAAgG;KACnG;IACD,uBAAuB,EAAE;QACvB,QAAQ,EACN,+PAA+P;QACjQ,OAAO,EACL,0FAA0F;KAC7F;IACD,iBAAiB,EAAE;QACjB,QAAQ,EACN,mGAAmG;QACrG,OAAO,EACL,sFAAsF;KACzF;CACwD,CAAC;AAE5D;;;;;GAKG;AACH,MAAM,SAAS,GAAG,aAAa,CAAC;AAEhC;;GAEG;AACH,SAAS,eAAe,CAAC,WAAkC;IACzD,OAAO;QACL,IAAI,EAAE;YACJ,IAAI,EAAE,SAAS;YACf,MAAM,EAAE,EAAE;YACV,QAAQ,EAAE,EAAE,CAAC,SAAS,CAAC,EAAE,WAAW,CAAC,OAAO,EAAE;SAC/C;QACD,MAAM,EAAE,CAAC,OAAwB,EAAe,EAAE,CAAC,CAAC;YAClD,CAAC,WAAW,CAAC,QAAQ,CAAC,EAAE,CAAC,IAAc,EAAQ,EAAE;gBAC/C,OAAO,CAAC,MAAM,CAAC,EAAE,IAAI,EAAE,SAAS,EAAE,CAAC,CAAC;YACtC,CAAC;SACF,CAAC;KACH,CAAC;AACJ,CAAC;AAED,SAAS,UAAU;IACjB,OAAO,MAAM,CAAC,WAAW,CACvB,MAAM,CAAC,OAAO,CAAC,sBAAsB,CAAC,CAAC,GAAG,CAAC,CAAC,CAAC,IAAI,EAAE,WAAW,CAAC,EAAE,EAAE,CAAC;QAClE,IAAI;QACJ,eAAe,CAAC,WAAW,CAAC;KAC7B,CAAC,CACH,CAAC;AACJ,CAAC;AAED;;;;;;GAMG;AACH,MAAM,CAAC,MAAM,cAAc,GAAe;IACxC,IAAI,EAAE,EAAE,IAAI,EAAE,kBAAkB,EAAE;IAClC,KAAK,EAAE,UAAU,EAAE;CACpB,CAAC;AAEF,eAAe,cAAc,CAAC"}

package/dist/config/oxlint/cffjs2.oxlint.config.d.ts

@@ -0,0 +1,26 @@
+import { type LintRuleSetting } from "../lint/index.js";
+/**
+ * An Oxlint config fragment, in the shape `.oxlintrc.json` is written in.
+ */
+export interface OxlintConfig {
+    readonly jsPlugins: readonly {
+        readonly name: string;
+        readonly specifier: string;
+    }[];
+    readonly overrides: readonly {
+        readonly files: readonly string[];
+        readonly rules: Readonly<Record<string, LintRuleSetting>>;
+    }[];
+}
+/**
+ * Oxlint's half of the CloudFront Functions JS2 lint setup.
+ *
+ * It is an override rather than a top-level rule block because a consumer
+ * extends this into the config that lints their whole repository, and JS2's
+ * restrictions would be wrong applied anywhere but a `.cff.js` file: a project
+ * told not to use arrow functions everywhere would be unusable.
+ *
+ * The rules are the same ones the ESLint config uses, from the same source.
+ */
+export declare const cloudFrontFunctionsJs2Oxlint: OxlintConfig;
+//# sourceMappingURL=cffjs2.oxlint.config.d.ts.map

package/dist/config/oxlint/cffjs2.oxlint.config.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cffjs2.oxlint.config.d.ts","sourceRoot":"","sources":["../../../src/config/oxlint/cffjs2.oxlint.config.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,eAAe,EACrB,MAAM,kBAAkB,CAAC;AAE1B;;GAEG;AACH,MAAM,WAAW,YAAY;IAC3B,QAAQ,CAAC,SAAS,EAAE,SAAS;QAC3B,QAAQ,CAAC,IAAI,EAAE,MAAM,CAAC;QACtB,QAAQ,CAAC,SAAS,EAAE,MAAM,CAAC;KAC5B,EAAE,CAAC;IACJ,QAAQ,CAAC,SAAS,EAAE,SAAS;QAC3B,QAAQ,CAAC,KAAK,EAAE,SAAS,MAAM,EAAE,CAAC;QAClC,QAAQ,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,eAAe,CAAC,CAAC,CAAC;KAC3D,EAAE,CAAC;CACL;AAUD;;;;;;;;;GASG;AACH,eAAO,MAAM,4BAA4B,EAAE,YAQ1C,CAAC"}

package/dist/config/oxlint/cffjs2.oxlint.config.js

@@ -0,0 +1,28 @@
+import { cffJs2LintRules, cffJs2PluginName, } from "../lint/index.js";
+/**
+ * Where the built plugin sits, relative to the built config that names it.
+ *
+ * Oxlint resolves a plugin specifier against the config file's own location,
+ * so this path is the one inside `dist/`, not the one in the source tree.
+ */
+const pluginSpecifier = "../lint/cff-js2-oxlint-plugin.js";
+/**
+ * Oxlint's half of the CloudFront Functions JS2 lint setup.
+ *
+ * It is an override rather than a top-level rule block because a consumer
+ * extends this into the config that lints their whole repository, and JS2's
+ * restrictions would be wrong applied anywhere but a `.cff.js` file: a project
+ * told not to use arrow functions everywhere would be unusable.
+ *
+ * The rules are the same ones the ESLint config uses, from the same source.
+ */
+export const cloudFrontFunctionsJs2Oxlint = {
+    jsPlugins: [{ name: cffJs2PluginName, specifier: pluginSpecifier }],
+    overrides: [
+        {
+            files: ["**/*.cff.js"],
+            rules: cffJs2LintRules(),
+        },
+    ],
+};
+//# sourceMappingURL=cffjs2.oxlint.config.js.map

package/dist/config/oxlint/cffjs2.oxlint.config.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"cffjs2.oxlint.config.js","sourceRoot":"","sources":["../../../src/config/oxlint/cffjs2.oxlint.config.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EACf,gBAAgB,GAEjB,MAAM,kBAAkB,CAAC;AAgB1B;;;;;GAKG;AACH,MAAM,eAAe,GAAG,kCAAkC,CAAC;AAE3D;;;;;;;;;GASG;AACH,MAAM,CAAC,MAAM,4BAA4B,GAAiB;IACxD,SAAS,EAAE,CAAC,EAAE,IAAI,EAAE,gBAAgB,EAAE,SAAS,EAAE,eAAe,EAAE,CAAC;IACnE,SAAS,EAAE;QACT;YACE,KAAK,EAAE,CAAC,aAAa,CAAC;YACtB,KAAK,EAAE,eAAe,EAAE;SACzB;KACF;CACF,CAAC"}

package/dist/config/oxlint/cffjs2.oxlintrc.json

@@ -0,0 +1,36 @@
+{
+  "jsPlugins": [
+    {
+      "name": "cff-js2",
+      "specifier": "../lint/cff-js2-oxlint-plugin.js"
+    }
+  ],
+  "overrides": [
+    {
+      "files": [
+        "**/*.cff.js"
+      ],
+      "rules": {
+        "object-shorthand": "off",
+        "no-eval": "error",
+        "no-new-func": "error",
+        "no-implied-eval": "error",
+        "no-unused-vars": [
+          "error",
+          {
+            "varsIgnorePattern": "^handler$"
+          }
+        ],
+        "cff-js2/no-unavailable-global": "error",
+        "cff-js2/no-import": "error",
+        "cff-js2/only-handler-export": "error",
+        "cff-js2/only-built-in-require": "error",
+        "cff-js2/no-class": "error",
+        "cff-js2/no-generator": "error",
+        "cff-js2/no-destructuring": "error",
+        "cff-js2/no-spread": "error",
+        "cff-js2/no-for-of": "error"
+      }
+    }
+  ]
+}

package/dist/config/oxlint/index.d.ts

@@ -0,0 +1,2 @@
+export { cloudFrontFunctionsJs2Oxlint, type OxlintConfig, } from "./cffjs2.oxlint.config.js";
+//# sourceMappingURL=index.d.ts.map

package/dist/config/oxlint/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/config/oxlint/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,4BAA4B,EAC5B,KAAK,YAAY,GAClB,MAAM,2BAA2B,CAAC"}

package/dist/config/oxlint/index.js

@@ -0,0 +1,2 @@
+export { cloudFrontFunctionsJs2Oxlint, } from "./cffjs2.oxlint.config.js";
+//# sourceMappingURL=index.js.map

package/dist/config/oxlint/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/config/oxlint/index.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,4BAA4B,GAE7B,MAAM,2BAA2B,CAAC"}

package/dist/sdk/module/sim-sdk-module-client-interceptor.js

@@ -28,7 +28,7 @@ export class SimSdkModuleClientInterceptor {
     interceptModule(moduleExports) {
         const intercepted = {};
         for (const [exportName, exportValue] of Object.entries(moduleExports)) {
-            // eslint-disable-next-line security/detect-object-injection -- copying the module's own export names verbatim.
+            // oxlint-disable-next-line security/detect-object-injection -- copying the module's own export names verbatim.
             intercepted[exportName] = this.interceptExport(exportValue);
         }
         return intercepted;