@cplieger/deadset-ts 8.0.0-dev.2 → 8.0.0-dev.20

package/src/vendor/unbash/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) Lars Kappert
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

package/src/vendor/unbash/VENDORED.md

@@ -0,0 +1,16 @@
+# unbash, vendored
+
+- Upstream: <https://github.com/webpro-nl/unbash>
+- Release: 6.0.0, commit `968c14992a43dc06ce29c9f51858abd4a87851ea`
+- License: ISC, in `LICENSE` beside this file
+
+`scripts/vendor-unbash.ts` writes this directory from a checkout of that commit: `npm run vendor -- <checkout>`. It copies `src/parser.ts` and every file it reaches through relative imports, which is every file of upstream's `src/` except `printer.ts`, and upstream's `LICENSE`.
+
+## Edits
+
+Each copied file is upstream's text with two lines put before it, and nothing else changed:
+
+1. `// Code generated by scripts/vendor-unbash.ts from unbash 6.0.0 (968c149…). DO NOT EDIT.`, so the dead-code self-check retains the copy as generated code.
+2. `// @ts-nocheck`, because upstream compiles under its own strict settings, which do not enable `noUncheckedIndexedAccess`, `exactOptionalPropertyTypes` or `noPropertyAccessFromIndexSignature`; under this repository's settings 96 of upstream's lines fail them.
+
+The directory is left out of ESLint (`eslint.config.mjs`), of Prettier (`.prettierignore`, which leaves out the generated contract modules too) and of the mutation targets (`stryker.config.json`, which leaves out the generated `src/conformance-record.ts` too). The repository measures no coverage, so nothing is left out of it.

package/src/vendor/unbash/ansi-c.ts

@@ -0,0 +1,132 @@
+// Code generated by scripts/vendor-unbash.ts from unbash 6.0.0 (968c14992a43dc06ce29c9f51858abd4a87851ea). DO NOT EDIT.
+// @ts-nocheck
+function isOctal(code: number): boolean {
+  return code >= 48 && code <= 55;
+}
+
+function isHex(code: number): boolean {
+  return (code >= 48 && code <= 57) || (code >= 65 && code <= 70) || (code >= 97 && code <= 102);
+}
+
+function codePoint(value: number, fallback: string): string {
+  try {
+    return String.fromCodePoint(value);
+  } catch {
+    return fallback;
+  }
+}
+
+export function decodeAnsiCQuoted(source: string, start: number, limit: number) {
+  let pos = start;
+  let value = "";
+
+  while (pos < limit && source.charCodeAt(pos) !== 39) {
+    if (source.charCodeAt(pos) !== 92 || pos + 1 >= limit) {
+      const runStart = pos;
+      while (pos < limit) {
+        const code = source.charCodeAt(pos);
+        // A backslash at the end of input has nothing to escape; consume it as a
+        // literal so the loop always advances.
+        if (code === 39 || (code === 92 && pos + 1 < limit)) break;
+        pos++;
+      }
+      value += source.slice(runStart, pos);
+      continue;
+    }
+
+    const escapeStart = pos++;
+    const escaped = source[pos++];
+    switch (escaped) {
+      case "a":
+        value += "\x07";
+        break;
+      case "b":
+        value += "\b";
+        break;
+      case "e":
+      case "E":
+        value += "\x1B";
+        break;
+      case "f":
+        value += "\f";
+        break;
+      case "n":
+        value += "\n";
+        break;
+      case "r":
+        value += "\r";
+        break;
+      case "t":
+        value += "\t";
+        break;
+      case "v":
+        value += "\v";
+        break;
+      case "\\":
+        value += "\\";
+        break;
+      case "'":
+        value += "'";
+        break;
+      case '"':
+        value += '"';
+        break;
+      case "?":
+        value += "?";
+        break;
+      case "\n":
+        break;
+      case "c": {
+        // The closing quote (or end of input) is not an operand: \c stays literal.
+        const code = pos < limit ? source.charCodeAt(pos) : 39;
+        if (code === 39) {
+          value += source.slice(escapeStart, pos);
+          break;
+        }
+        pos++;
+        if (code === 92) {
+          // Bash writes a backslash operand as the pair \c\\; a lone backslash
+          // still decodes and leaves the character it escaped as a literal.
+          const pair = pos < limit && source.charCodeAt(pos) === 92;
+          if (pair) pos++;
+          value += "\x1c";
+          if (!pair && pos < limit) {
+            value += source[pos];
+            pos++;
+          }
+          break;
+        }
+        value += String.fromCharCode(code === 63 ? 127 : code & 31);
+        break;
+      }
+      case "x":
+      case "u":
+      case "U": {
+        const digitsStart = pos;
+        const maxDigits = escaped === "x" ? 2 : escaped === "u" ? 4 : 8;
+        while (pos < limit && pos - digitsStart < maxDigits && isHex(source.charCodeAt(pos))) pos++;
+        if (pos === digitsStart) {
+          value += `\\${escaped}`;
+          break;
+        }
+        const raw = source.slice(escapeStart, pos);
+        value += codePoint(Number.parseInt(source.slice(digitsStart, pos), 16), raw);
+        break;
+      }
+      default: {
+        const escapedCode = escaped.charCodeAt(0);
+        if (!isOctal(escapedCode)) {
+          value += `\\${escaped}`;
+          break;
+        }
+        while (pos < limit && pos - escapeStart - 1 < 3 && isOctal(source.charCodeAt(pos))) pos++;
+        value += String.fromCharCode(Number.parseInt(source.slice(escapeStart + 1, pos), 8) & 0xff);
+        break;
+      }
+    }
+  }
+
+  const closed = pos < limit;
+  if (closed) pos++;
+  return { value, end: pos, closed };
+}

package/src/vendor/unbash/arithmetic-parts.ts

@@ -0,0 +1,53 @@
+// Code generated by scripts/vendor-unbash.ts from unbash 6.0.0 (968c14992a43dc06ce29c9f51858abd4a87851ea). DO NOT EDIT.
+// @ts-nocheck
+import { parseArithmeticExpression } from "./arithmetic.ts";
+import { hasEmbeddedWordStructure, Lexer } from "./lexer.ts";
+import { computeEmbeddedWordParts } from "./parts.ts";
+import { ScriptExpansionImpl } from "./expansion.ts";
+import { MAX_SYNTAX_NESTING } from "./limits.ts";
+import type { ArithmeticExpression, ArithmeticWord } from "./internal-types.ts";
+import type { SubstitutionContext } from "./substitution-context.ts";
+
+export function parseArithmeticWithParts(
+  body: string,
+  offset: number,
+  source: string,
+  depth: number,
+  context: SubstitutionContext,
+  embeddedDepth = depth,
+): ArithmeticExpression | undefined {
+  if (!hasEmbeddedWordStructure(source, offset, offset + body.length)) {
+    return parseArithmeticExpression(body, offset, undefined, depth) ?? undefined;
+  }
+  const embeddedWords: ArithmeticWord[] = [];
+  const lexer = new Lexer(source, 0, source.length, false, context);
+  lexer._nestingDepth = depth;
+  const expression =
+    parseArithmeticExpression(
+      body,
+      offset,
+      {
+        embeddedWords,
+        commandExpansion: (pos, end, text) =>
+          new ScriptExpansionImpl("ArithmeticCommandExpansion", pos, end, text, {
+            source,
+            start: pos + 2,
+            end: end - 1,
+            depth: depth + 1,
+            parenBoundary: true,
+            context,
+          }),
+        findClosingBracket: (start, end) => lexer.findClosingBracket(start, end),
+        findClosingBrace: (start, end) => lexer.findClosingBrace(start, end),
+        findClosingParenthesis: (start, end) => lexer.findClosingParenthesis(start, end),
+        findArithmeticExpansionEnd: (start, end) => lexer.findArithmeticExpansionEnd(start, end),
+        findArithmeticWordEnd: (start, end) => lexer.findArithmeticWordEnd(start, end),
+      },
+      depth,
+    ) ?? undefined;
+  // Past the nesting budget an embedded word keeps its text without parts.
+  if (embeddedDepth <= MAX_SYNTAX_NESTING) {
+    for (const node of embeddedWords) node.parts = computeEmbeddedWordParts(source, node, embeddedDepth, context, true);
+  }
+  return expression;
+}