corsa-oxlint 0.1.0

package/dist/rules/index.d.ts

@@ -0,0 +1,473 @@
+declare namespace index_d_exports {
+  export { implementedNativeRuleNames, pendingNativeRuleNames, typescriptOxlintPlugin, typescriptOxlintRules };
+}
+declare const implementedNativeRuleNames: readonly ["await-thenable", "no-array-delete", "no-base-to-string", "no-floating-promises", "no-for-in-array", "no-implied-eval", "no-mixed-enums", "no-unsafe-assignment", "no-unsafe-return", "no-unsafe-unary-minus", "only-throw-error", "prefer-find", "prefer-includes", "prefer-promise-reject-errors", "prefer-regexp-exec", "prefer-string-starts-ends-with", "require-array-sort-compare", "restrict-plus-operands", "use-unknown-in-catch-callback-variable"];
+declare const pendingNativeRuleNames: readonly ["consistent-return", "consistent-type-exports", "dot-notation", "no-confusing-void-expression", "no-deprecated", "no-duplicate-type-constituents", "no-meaningless-void-operator", "no-misused-promises", "no-misused-spread", "no-redundant-type-constituents", "no-unnecessary-boolean-literal-compare", "no-unnecessary-condition", "no-unnecessary-qualifier", "no-unnecessary-template-expression", "no-unnecessary-type-arguments", "no-unnecessary-type-assertion", "no-unnecessary-type-conversion", "no-unnecessary-type-parameters", "no-unsafe-argument", "no-unsafe-call", "no-unsafe-enum-comparison", "no-unsafe-member-access", "no-unsafe-type-assertion", "no-useless-default-assignment", "non-nullable-type-assertion-style", "prefer-nullish-coalescing", "prefer-optional-chain", "prefer-readonly", "prefer-readonly-parameter-types", "prefer-reduce-type-parameter", "prefer-return-this-type", "promise-function-async", "related-getter-setter-pairs", "require-await", "restrict-template-expressions", "return-await", "strict-boolean-expressions", "strict-void-return", "switch-exhaustiveness-check", "unbound-method"];
+declare const typescriptOxlintRules: Readonly<{
+  "await-thenable": {
+    defaultOptions: never[];
+    meta: {
+      docs: {
+        requiresTypeChecking: boolean;
+        url: string;
+      };
+      type: "problem";
+      schema: never[];
+    };
+    create: (context: any) => Record<string, (node: any) => void>;
+  };
+  "no-array-delete": {
+    defaultOptions: never[];
+    meta: {
+      docs: {
+        requiresTypeChecking: boolean;
+        url: string;
+      };
+      type: "problem";
+      schema: never[];
+    };
+    create: (context: any) => Record<string, (node: any) => void>;
+  };
+  "no-base-to-string": {
+    defaultOptions: never[];
+    meta: {
+      docs: {
+        requiresTypeChecking: boolean;
+        url: string;
+      };
+      type: "problem";
+      schema: never[];
+    };
+    create: (context: any) => Record<string, (node: any) => void>;
+  };
+  "no-floating-promises": {
+    defaultOptions: never[];
+    meta: {
+      docs: {
+        requiresTypeChecking: boolean;
+        url: string;
+      };
+      type: "problem";
+      schema: never[];
+    };
+    create: (context: any) => Record<string, (node: any) => void>;
+  };
+  "no-for-in-array": {
+    defaultOptions: never[];
+    meta: {
+      docs: {
+        requiresTypeChecking: boolean;
+        url: string;
+      };
+      type: "problem";
+      schema: never[];
+    };
+    create: (context: any) => Record<string, (node: any) => void>;
+  };
+  "no-implied-eval": {
+    defaultOptions: never[];
+    meta: {
+      docs: {
+        requiresTypeChecking: boolean;
+        url: string;
+      };
+      type: "problem";
+      schema: never[];
+    };
+    create: (context: any) => Record<string, (node: any) => void>;
+  };
+  "no-mixed-enums": {
+    defaultOptions: never[];
+    meta: {
+      docs: {
+        requiresTypeChecking: boolean;
+        url: string;
+      };
+      type: "problem";
+      schema: never[];
+    };
+    create: (context: any) => Record<string, (node: any) => void>;
+  };
+  "no-unsafe-assignment": {
+    defaultOptions: never[];
+    meta: {
+      docs: {
+        requiresTypeChecking: boolean;
+        url: string;
+      };
+      type: "problem";
+      schema: never[];
+    };
+    create: (context: any) => Record<string, (node: any) => void>;
+  };
+  "no-unsafe-return": {
+    defaultOptions: never[];
+    meta: {
+      docs: {
+        requiresTypeChecking: boolean;
+        url: string;
+      };
+      type: "problem";
+      schema: never[];
+    };
+    create: (context: any) => Record<string, (node: any) => void>;
+  };
+  "no-unsafe-unary-minus": {
+    defaultOptions: never[];
+    meta: {
+      docs: {
+        requiresTypeChecking: boolean;
+        url: string;
+      };
+      type: "problem";
+      schema: never[];
+    };
+    create: (context: any) => Record<string, (node: any) => void>;
+  };
+  "only-throw-error": {
+    defaultOptions: never[];
+    meta: {
+      docs: {
+        requiresTypeChecking: boolean;
+        url: string;
+      };
+      type: "problem";
+      schema: never[];
+    };
+    create: (context: any) => Record<string, (node: any) => void>;
+  };
+  "prefer-find": {
+    defaultOptions: never[];
+    meta: {
+      docs: {
+        requiresTypeChecking: boolean;
+        url: string;
+      };
+      type: "problem";
+      schema: never[];
+    };
+    create: (context: any) => Record<string, (node: any) => void>;
+  };
+  "prefer-includes": {
+    defaultOptions: never[];
+    meta: {
+      docs: {
+        requiresTypeChecking: boolean;
+        url: string;
+      };
+      type: "problem";
+      schema: never[];
+    };
+    create: (context: any) => Record<string, (node: any) => void>;
+  };
+  "prefer-promise-reject-errors": {
+    defaultOptions: never[];
+    meta: {
+      docs: {
+        requiresTypeChecking: boolean;
+        url: string;
+      };
+      type: "problem";
+      schema: never[];
+    };
+    create: (context: any) => Record<string, (node: any) => void>;
+  };
+  "prefer-regexp-exec": {
+    defaultOptions: never[];
+    meta: {
+      docs: {
+        requiresTypeChecking: boolean;
+        url: string;
+      };
+      type: "problem";
+      schema: never[];
+    };
+    create: (context: any) => Record<string, (node: any) => void>;
+  };
+  "prefer-string-starts-ends-with": {
+    defaultOptions: never[];
+    meta: {
+      docs: {
+        requiresTypeChecking: boolean;
+        url: string;
+      };
+      type: "problem";
+      schema: never[];
+    };
+    create: (context: any) => Record<string, (node: any) => void>;
+  };
+  "require-array-sort-compare": {
+    defaultOptions: never[];
+    meta: {
+      docs: {
+        requiresTypeChecking: boolean;
+        url: string;
+      };
+      type: "problem";
+      schema: never[];
+    };
+    create: (context: any) => Record<string, (node: any) => void>;
+  };
+  "restrict-plus-operands": {
+    defaultOptions: never[];
+    meta: {
+      docs: {
+        requiresTypeChecking: boolean;
+        url: string;
+      };
+      type: "problem";
+      schema: never[];
+    };
+    create: (context: any) => Record<string, (node: any) => void>;
+  };
+  "use-unknown-in-catch-callback-variable": {
+    defaultOptions: never[];
+    meta: {
+      docs: {
+        requiresTypeChecking: boolean;
+        url: string;
+      };
+      type: "problem";
+      schema: never[];
+    };
+    create: (context: any) => Record<string, (node: any) => void>;
+  };
+}>;
+declare const typescriptOxlintPlugin: {
+  meta: {
+    name: string;
+  };
+  rules: Readonly<{
+    "await-thenable": {
+      defaultOptions: never[];
+      meta: {
+        docs: {
+          requiresTypeChecking: boolean;
+          url: string;
+        };
+        type: "problem";
+        schema: never[];
+      };
+      create: (context: any) => Record<string, (node: any) => void>;
+    };
+    "no-array-delete": {
+      defaultOptions: never[];
+      meta: {
+        docs: {
+          requiresTypeChecking: boolean;
+          url: string;
+        };
+        type: "problem";
+        schema: never[];
+      };
+      create: (context: any) => Record<string, (node: any) => void>;
+    };
+    "no-base-to-string": {
+      defaultOptions: never[];
+      meta: {
+        docs: {
+          requiresTypeChecking: boolean;
+          url: string;
+        };
+        type: "problem";
+        schema: never[];
+      };
+      create: (context: any) => Record<string, (node: any) => void>;
+    };
+    "no-floating-promises": {
+      defaultOptions: never[];
+      meta: {
+        docs: {
+          requiresTypeChecking: boolean;
+          url: string;
+        };
+        type: "problem";
+        schema: never[];
+      };
+      create: (context: any) => Record<string, (node: any) => void>;
+    };
+    "no-for-in-array": {
+      defaultOptions: never[];
+      meta: {
+        docs: {
+          requiresTypeChecking: boolean;
+          url: string;
+        };
+        type: "problem";
+        schema: never[];
+      };
+      create: (context: any) => Record<string, (node: any) => void>;
+    };
+    "no-implied-eval": {
+      defaultOptions: never[];
+      meta: {
+        docs: {
+          requiresTypeChecking: boolean;
+          url: string;
+        };
+        type: "problem";
+        schema: never[];
+      };
+      create: (context: any) => Record<string, (node: any) => void>;
+    };
+    "no-mixed-enums": {
+      defaultOptions: never[];
+      meta: {
+        docs: {
+          requiresTypeChecking: boolean;
+          url: string;
+        };
+        type: "problem";
+        schema: never[];
+      };
+      create: (context: any) => Record<string, (node: any) => void>;
+    };
+    "no-unsafe-assignment": {
+      defaultOptions: never[];
+      meta: {
+        docs: {
+          requiresTypeChecking: boolean;
+          url: string;
+        };
+        type: "problem";
+        schema: never[];
+      };
+      create: (context: any) => Record<string, (node: any) => void>;
+    };
+    "no-unsafe-return": {
+      defaultOptions: never[];
+      meta: {
+        docs: {
+          requiresTypeChecking: boolean;
+          url: string;
+        };
+        type: "problem";
+        schema: never[];
+      };
+      create: (context: any) => Record<string, (node: any) => void>;
+    };
+    "no-unsafe-unary-minus": {
+      defaultOptions: never[];
+      meta: {
+        docs: {
+          requiresTypeChecking: boolean;
+          url: string;
+        };
+        type: "problem";
+        schema: never[];
+      };
+      create: (context: any) => Record<string, (node: any) => void>;
+    };
+    "only-throw-error": {
+      defaultOptions: never[];
+      meta: {
+        docs: {
+          requiresTypeChecking: boolean;
+          url: string;
+        };
+        type: "problem";
+        schema: never[];
+      };
+      create: (context: any) => Record<string, (node: any) => void>;
+    };
+    "prefer-find": {
+      defaultOptions: never[];
+      meta: {
+        docs: {
+          requiresTypeChecking: boolean;
+          url: string;
+        };
+        type: "problem";
+        schema: never[];
+      };
+      create: (context: any) => Record<string, (node: any) => void>;
+    };
+    "prefer-includes": {
+      defaultOptions: never[];
+      meta: {
+        docs: {
+          requiresTypeChecking: boolean;
+          url: string;
+        };
+        type: "problem";
+        schema: never[];
+      };
+      create: (context: any) => Record<string, (node: any) => void>;
+    };
+    "prefer-promise-reject-errors": {
+      defaultOptions: never[];
+      meta: {
+        docs: {
+          requiresTypeChecking: boolean;
+          url: string;
+        };
+        type: "problem";
+        schema: never[];
+      };
+      create: (context: any) => Record<string, (node: any) => void>;
+    };
+    "prefer-regexp-exec": {
+      defaultOptions: never[];
+      meta: {
+        docs: {
+          requiresTypeChecking: boolean;
+          url: string;
+        };
+        type: "problem";
+        schema: never[];
+      };
+      create: (context: any) => Record<string, (node: any) => void>;
+    };
+    "prefer-string-starts-ends-with": {
+      defaultOptions: never[];
+      meta: {
+        docs: {
+          requiresTypeChecking: boolean;
+          url: string;
+        };
+        type: "problem";
+        schema: never[];
+      };
+      create: (context: any) => Record<string, (node: any) => void>;
+    };
+    "require-array-sort-compare": {
+      defaultOptions: never[];
+      meta: {
+        docs: {
+          requiresTypeChecking: boolean;
+          url: string;
+        };
+        type: "problem";
+        schema: never[];
+      };
+      create: (context: any) => Record<string, (node: any) => void>;
+    };
+    "restrict-plus-operands": {
+      defaultOptions: never[];
+      meta: {
+        docs: {
+          requiresTypeChecking: boolean;
+          url: string;
+        };
+        type: "problem";
+        schema: never[];
+      };
+      create: (context: any) => Record<string, (node: any) => void>;
+    };
+    "use-unknown-in-catch-callback-variable": {
+      defaultOptions: never[];
+      meta: {
+        docs: {
+          requiresTypeChecking: boolean;
+          url: string;
+        };
+        type: "problem";
+        schema: never[];
+      };
+      create: (context: any) => Record<string, (node: any) => void>;
+    };
+  }>;
+};
+//#endregion
+export { implementedNativeRuleNames, index_d_exports, pendingNativeRuleNames, typescriptOxlintPlugin, typescriptOxlintRules };
+//# sourceMappingURL=index.d.ts.map

package/dist/rules/index.js

@@ -0,0 +1,120 @@
+import { __exportAll } from "../_virtual/_rolldown/runtime.js";
+import { definePlugin } from "../plugin.js";
+import { awaitThenableRule } from "./await_thenable.js";
+import { noArrayDeleteRule } from "./no_array_delete.js";
+import { noBaseToStringRule } from "./no_base_to_string.js";
+import { noFloatingPromisesRule } from "./no_floating_promises.js";
+import { noForInArrayRule } from "./no_for_in_array.js";
+import { noImpliedEvalRule } from "./no_implied_eval.js";
+import { noMixedEnumsRule } from "./no_mixed_enums.js";
+import { noUnsafeAssignmentRule } from "./no_unsafe_assignment.js";
+import { noUnsafeReturnRule } from "./no_unsafe_return.js";
+import { noUnsafeUnaryMinusRule } from "./no_unsafe_unary_minus.js";
+import { onlyThrowErrorRule } from "./only_throw_error.js";
+import { preferFindRule } from "./prefer_find.js";
+import { preferIncludesRule } from "./prefer_includes.js";
+import { preferPromiseRejectErrorsRule } from "./prefer_promise_reject_errors.js";
+import { preferRegexpExecRule } from "./prefer_regexp_exec.js";
+import { preferStringStartsEndsWithRule } from "./prefer_string_starts_ends_with.js";
+import { requireArraySortCompareRule } from "./require_array_sort_compare.js";
+import { restrictPlusOperandsRule } from "./restrict_plus_operands.js";
+import { useUnknownInCatchCallbackVariableRule } from "./use_unknown_in_catch_callback_variable.js";
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/index.ts
+var rules_exports = /* @__PURE__ */ __exportAll({
+	implementedNativeRuleNames: () => implementedNativeRuleNames,
+	pendingNativeRuleNames: () => pendingNativeRuleNames,
+	typescriptOxlintPlugin: () => typescriptOxlintPlugin,
+	typescriptOxlintRules: () => typescriptOxlintRules
+});
+const implementedNativeRuleNames = [
+	"await-thenable",
+	"no-array-delete",
+	"no-base-to-string",
+	"no-floating-promises",
+	"no-for-in-array",
+	"no-implied-eval",
+	"no-mixed-enums",
+	"no-unsafe-assignment",
+	"no-unsafe-return",
+	"no-unsafe-unary-minus",
+	"only-throw-error",
+	"prefer-find",
+	"prefer-includes",
+	"prefer-promise-reject-errors",
+	"prefer-regexp-exec",
+	"prefer-string-starts-ends-with",
+	"require-array-sort-compare",
+	"restrict-plus-operands",
+	"use-unknown-in-catch-callback-variable"
+];
+const pendingNativeRuleNames = [
+	"consistent-return",
+	"consistent-type-exports",
+	"dot-notation",
+	"no-confusing-void-expression",
+	"no-deprecated",
+	"no-duplicate-type-constituents",
+	"no-meaningless-void-operator",
+	"no-misused-promises",
+	"no-misused-spread",
+	"no-redundant-type-constituents",
+	"no-unnecessary-boolean-literal-compare",
+	"no-unnecessary-condition",
+	"no-unnecessary-qualifier",
+	"no-unnecessary-template-expression",
+	"no-unnecessary-type-arguments",
+	"no-unnecessary-type-assertion",
+	"no-unnecessary-type-conversion",
+	"no-unnecessary-type-parameters",
+	"no-unsafe-argument",
+	"no-unsafe-call",
+	"no-unsafe-enum-comparison",
+	"no-unsafe-member-access",
+	"no-unsafe-type-assertion",
+	"no-useless-default-assignment",
+	"non-nullable-type-assertion-style",
+	"prefer-nullish-coalescing",
+	"prefer-optional-chain",
+	"prefer-readonly",
+	"prefer-readonly-parameter-types",
+	"prefer-reduce-type-parameter",
+	"prefer-return-this-type",
+	"promise-function-async",
+	"related-getter-setter-pairs",
+	"require-await",
+	"restrict-template-expressions",
+	"return-await",
+	"strict-boolean-expressions",
+	"strict-void-return",
+	"switch-exhaustiveness-check",
+	"unbound-method"
+];
+const typescriptOxlintRules = Object.freeze({
+	"await-thenable": awaitThenableRule,
+	"no-array-delete": noArrayDeleteRule,
+	"no-base-to-string": noBaseToStringRule,
+	"no-floating-promises": noFloatingPromisesRule,
+	"no-for-in-array": noForInArrayRule,
+	"no-implied-eval": noImpliedEvalRule,
+	"no-mixed-enums": noMixedEnumsRule,
+	"no-unsafe-assignment": noUnsafeAssignmentRule,
+	"no-unsafe-return": noUnsafeReturnRule,
+	"no-unsafe-unary-minus": noUnsafeUnaryMinusRule,
+	"only-throw-error": onlyThrowErrorRule,
+	"prefer-find": preferFindRule,
+	"prefer-includes": preferIncludesRule,
+	"prefer-promise-reject-errors": preferPromiseRejectErrorsRule,
+	"prefer-regexp-exec": preferRegexpExecRule,
+	"prefer-string-starts-ends-with": preferStringStartsEndsWithRule,
+	"require-array-sort-compare": requireArraySortCompareRule,
+	"restrict-plus-operands": restrictPlusOperandsRule,
+	"use-unknown-in-catch-callback-variable": useUnknownInCatchCallbackVariableRule
+});
+const typescriptOxlintPlugin = definePlugin({
+	meta: { name: "oxlint-plugin-typescript-go" },
+	rules: typescriptOxlintRules
+});
+//#endregion
+export { implementedNativeRuleNames, pendingNativeRuleNames, rules_exports, typescriptOxlintPlugin, typescriptOxlintRules };
+
+//# sourceMappingURL=index.js.map

package/dist/rules/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","names":[],"sources":["../../ts/rules/index.ts"],"sourcesContent":["import { definePlugin } from \"../plugin\";\n\nimport { awaitThenableRule } from \"./await_thenable\";\nimport { noArrayDeleteRule } from \"./no_array_delete\";\nimport { noBaseToStringRule } from \"./no_base_to_string\";\nimport { noFloatingPromisesRule } from \"./no_floating_promises\";\nimport { noForInArrayRule } from \"./no_for_in_array\";\nimport { noImpliedEvalRule } from \"./no_implied_eval\";\nimport { noMixedEnumsRule } from \"./no_mixed_enums\";\nimport { noUnsafeAssignmentRule } from \"./no_unsafe_assignment\";\nimport { noUnsafeReturnRule } from \"./no_unsafe_return\";\nimport { noUnsafeUnaryMinusRule } from \"./no_unsafe_unary_minus\";\nimport { onlyThrowErrorRule } from \"./only_throw_error\";\nimport { preferFindRule } from \"./prefer_find\";\nimport { preferIncludesRule } from \"./prefer_includes\";\nimport { preferPromiseRejectErrorsRule } from \"./prefer_promise_reject_errors\";\nimport { preferRegexpExecRule } from \"./prefer_regexp_exec\";\nimport { preferStringStartsEndsWithRule } from \"./prefer_string_starts_ends_with\";\nimport { requireArraySortCompareRule } from \"./require_array_sort_compare\";\nimport { restrictPlusOperandsRule } from \"./restrict_plus_operands\";\nimport { useUnknownInCatchCallbackVariableRule } from \"./use_unknown_in_catch_callback_variable\";\n\nexport const implementedNativeRuleNames = [\n  \"await-thenable\",\n  \"no-array-delete\",\n  \"no-base-to-string\",\n  \"no-floating-promises\",\n  \"no-for-in-array\",\n  \"no-implied-eval\",\n  \"no-mixed-enums\",\n  \"no-unsafe-assignment\",\n  \"no-unsafe-return\",\n  \"no-unsafe-unary-minus\",\n  \"only-throw-error\",\n  \"prefer-find\",\n  \"prefer-includes\",\n  \"prefer-promise-reject-errors\",\n  \"prefer-regexp-exec\",\n  \"prefer-string-starts-ends-with\",\n  \"require-array-sort-compare\",\n  \"restrict-plus-operands\",\n  \"use-unknown-in-catch-callback-variable\",\n] as const;\n\nexport const pendingNativeRuleNames = [\n  \"consistent-return\",\n  \"consistent-type-exports\",\n  \"dot-notation\",\n  \"no-confusing-void-expression\",\n  \"no-deprecated\",\n  \"no-duplicate-type-constituents\",\n  \"no-meaningless-void-operator\",\n  \"no-misused-promises\",\n  \"no-misused-spread\",\n  \"no-redundant-type-constituents\",\n  \"no-unnecessary-boolean-literal-compare\",\n  \"no-unnecessary-condition\",\n  \"no-unnecessary-qualifier\",\n  \"no-unnecessary-template-expression\",\n  \"no-unnecessary-type-arguments\",\n  \"no-unnecessary-type-assertion\",\n  \"no-unnecessary-type-conversion\",\n  \"no-unnecessary-type-parameters\",\n  \"no-unsafe-argument\",\n  \"no-unsafe-call\",\n  \"no-unsafe-enum-comparison\",\n  \"no-unsafe-member-access\",\n  \"no-unsafe-type-assertion\",\n  \"no-useless-default-assignment\",\n  \"non-nullable-type-assertion-style\",\n  \"prefer-nullish-coalescing\",\n  \"prefer-optional-chain\",\n  \"prefer-readonly\",\n  \"prefer-readonly-parameter-types\",\n  \"prefer-reduce-type-parameter\",\n  \"prefer-return-this-type\",\n  \"promise-function-async\",\n  \"related-getter-setter-pairs\",\n  \"require-await\",\n  \"restrict-template-expressions\",\n  \"return-await\",\n  \"strict-boolean-expressions\",\n  \"strict-void-return\",\n  \"switch-exhaustiveness-check\",\n  \"unbound-method\",\n] as const;\n\nexport const typescriptOxlintRules = Object.freeze({\n  \"await-thenable\": awaitThenableRule,\n  \"no-array-delete\": noArrayDeleteRule,\n  \"no-base-to-string\": noBaseToStringRule,\n  \"no-floating-promises\": noFloatingPromisesRule,\n  \"no-for-in-array\": noForInArrayRule,\n  \"no-implied-eval\": noImpliedEvalRule,\n  \"no-mixed-enums\": noMixedEnumsRule,\n  \"no-unsafe-assignment\": noUnsafeAssignmentRule,\n  \"no-unsafe-return\": noUnsafeReturnRule,\n  \"no-unsafe-unary-minus\": noUnsafeUnaryMinusRule,\n  \"only-throw-error\": onlyThrowErrorRule,\n  \"prefer-find\": preferFindRule,\n  \"prefer-includes\": preferIncludesRule,\n  \"prefer-promise-reject-errors\": preferPromiseRejectErrorsRule,\n  \"prefer-regexp-exec\": preferRegexpExecRule,\n  \"prefer-string-starts-ends-with\": preferStringStartsEndsWithRule,\n  \"require-array-sort-compare\": requireArraySortCompareRule,\n  \"restrict-plus-operands\": restrictPlusOperandsRule,\n  \"use-unknown-in-catch-callback-variable\": useUnknownInCatchCallbackVariableRule,\n});\n\nexport const typescriptOxlintPlugin = definePlugin({\n  meta: { name: \"oxlint-plugin-typescript-go\" },\n  rules: typescriptOxlintRules,\n});\n"],"mappings":";;;;;;;;;;;;;;;;;;;;;;;;;;;;AAsBA,MAAa,6BAA6B;CACxC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD;AAED,MAAa,yBAAyB;CACpC;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACA;CACD;AAED,MAAa,wBAAwB,OAAO,OAAO;CACjD,kBAAkB;CAClB,mBAAmB;CACnB,qBAAqB;CACrB,wBAAwB;CACxB,mBAAmB;CACnB,mBAAmB;CACnB,kBAAkB;CAClB,wBAAwB;CACxB,oBAAoB;CACpB,yBAAyB;CACzB,oBAAoB;CACpB,eAAe;CACf,mBAAmB;CACnB,gCAAgC;CAChC,sBAAsB;CACtB,kCAAkC;CAClC,8BAA8B;CAC9B,0BAA0B;CAC1B,0CAA0C;CAC3C,CAAC;AAEF,MAAa,yBAAyB,aAAa;CACjD,MAAM,EAAE,MAAM,+BAA+B;CAC7C,OAAO;CACR,CAAC"}

package/dist/rules/no_array_delete.d.ts

@@ -0,0 +1,16 @@
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/no_array_delete.d.ts
+declare const noArrayDeleteRule: {
+  defaultOptions: never[];
+  meta: {
+    docs: {
+      requiresTypeChecking: boolean;
+      url: string;
+    };
+    type: "problem";
+    schema: never[];
+  };
+  create: (context: any) => Record<string, (node: any) => void>;
+};
+//#endregion
+export { noArrayDeleteRule };
+//# sourceMappingURL=no_array_delete.d.ts.map

package/dist/rules/no_array_delete.js

@@ -0,0 +1,29 @@
+import { createNativeRule } from "./rule_creator.js";
+import { isArrayLikeNode } from "./type_utils.js";
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/no_array_delete.ts
+const noArrayDeleteRule = createNativeRule("no-array-delete", {
+	docs: { description: "Disallow deleting elements from array-like values." },
+	hasSuggestions: true,
+	messages: {
+		unexpected: "Do not delete elements from an array-like value.",
+		useSplice: "Use array.splice(index, 1) instead."
+	}
+}, (context) => ({ UnaryExpression(node) {
+	if (node.operator !== "delete" || node.argument?.type !== "MemberExpression" || !node.argument.computed) return;
+	if (isArrayLikeNode(context, node.argument.object)) context.report({
+		node,
+		messageId: "unexpected",
+		suggest: [{
+			messageId: "useSplice",
+			fix: (fixer) => [
+				fixer.removeRange([node.range[0], node.argument.object.range[1]]),
+				fixer.replaceTextRange([node.argument.object.range[1], node.argument.property.range[0]], ".splice("),
+				fixer.replaceTextRange([node.argument.property.range[1], node.argument.range[1]], ", 1)")
+			]
+		}]
+	});
+} }));
+//#endregion
+export { noArrayDeleteRule };
+
+//# sourceMappingURL=no_array_delete.js.map

package/dist/rules/no_array_delete.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"no_array_delete.js","names":[],"sources":["../../ts/rules/no_array_delete.ts"],"sourcesContent":["import { createNativeRule } from \"./rule_creator\";\nimport { isArrayLikeNode } from \"./type_utils\";\n\nexport const noArrayDeleteRule = createNativeRule(\n  \"no-array-delete\",\n  {\n    docs: {\n      description: \"Disallow deleting elements from array-like values.\",\n    },\n    hasSuggestions: true,\n    messages: {\n      unexpected: \"Do not delete elements from an array-like value.\",\n      useSplice: \"Use array.splice(index, 1) instead.\",\n    },\n  },\n  (context) => ({\n    UnaryExpression(node: any) {\n      if (\n        node.operator !== \"delete\" ||\n        node.argument?.type !== \"MemberExpression\" ||\n        !node.argument.computed\n      ) {\n        return;\n      }\n      if (isArrayLikeNode(context, node.argument.object)) {\n        context.report({\n          node,\n          messageId: \"unexpected\",\n          suggest: [\n            {\n              messageId: \"useSplice\",\n              fix: (fixer: any) => [\n                fixer.removeRange([node.range[0], node.argument.object.range[1]]),\n                fixer.replaceTextRange(\n                  [node.argument.object.range[1], node.argument.property.range[0]],\n                  \".splice(\",\n                ),\n                fixer.replaceTextRange(\n                  [node.argument.property.range[1], node.argument.range[1]],\n                  \", 1)\",\n                ),\n              ],\n            },\n          ],\n        });\n      }\n    },\n  }),\n);\n"],"mappings":";;;AAGA,MAAa,oBAAoB,iBAC/B,mBACA;CACE,MAAM,EACJ,aAAa,sDACd;CACD,gBAAgB;CAChB,UAAU;EACR,YAAY;EACZ,WAAW;EACZ;CACF,GACA,aAAa,EACZ,gBAAgB,MAAW;AACzB,KACE,KAAK,aAAa,YAClB,KAAK,UAAU,SAAS,sBACxB,CAAC,KAAK,SAAS,SAEf;AAEF,KAAI,gBAAgB,SAAS,KAAK,SAAS,OAAO,CAChD,SAAQ,OAAO;EACb;EACA,WAAW;EACX,SAAS,CACP;GACE,WAAW;GACX,MAAM,UAAe;IACnB,MAAM,YAAY,CAAC,KAAK,MAAM,IAAI,KAAK,SAAS,OAAO,MAAM,GAAG,CAAC;IACjE,MAAM,iBACJ,CAAC,KAAK,SAAS,OAAO,MAAM,IAAI,KAAK,SAAS,SAAS,MAAM,GAAG,EAChE,WACD;IACD,MAAM,iBACJ,CAAC,KAAK,SAAS,SAAS,MAAM,IAAI,KAAK,SAAS,MAAM,GAAG,EACzD,OACD;IACF;GACF,CACF;EACF,CAAC;GAGP,EACF"}

package/dist/rules/no_base_to_string.d.ts

@@ -0,0 +1,16 @@
+//#region src/bindings/nodejs/typescript_oxlint/ts/rules/no_base_to_string.d.ts
+declare const noBaseToStringRule: {
+  defaultOptions: never[];
+  meta: {
+    docs: {
+      requiresTypeChecking: boolean;
+      url: string;
+    };
+    type: "problem";
+    schema: never[];
+  };
+  create: (context: any) => Record<string, (node: any) => void>;
+};
+//#endregion
+export { noBaseToStringRule };
+//# sourceMappingURL=no_base_to_string.d.ts.map