This is because .slice does a shallow copy and does not copy nested objects. Since you are using two dimensional array, this is expected.

Use: const input = JSON.parse(JSON.stringify(linsys))

Shallow cloning does not copy nested objects. So if an object contains an object, your .slice will keep a reference to the original copy of that object rather than creating a copy. Hence, the value changes.

In case of a shallow copy-

• Objects will reflect change in the original place from where they were shallowly copied because they are stored as references (to their address in the Heap).
• Primitive data types will NOT reflect change in the original place because they are directly stored in the callstack (in Execution Contexts).

For example:

var a = [
    [1, 2],    // This still is referencing to the original reference 
    [5,7]
]

“If [ignorance is] the answer than fine.” Nah, you’re not ignorant. If you’re ignorant, then I’m ignorant. You’re exploring the type system and doing interesting things, and you’re using good linter rules. That leads to correct, but sometimes unintuitive errors.

Yes, you can do what you’re asking (code examples at end):

• Example 1: In the general case where you split arguments of known types, your usage example is essentially correct, except for one case: say you want to operate on the first element and then recursively pass the rest, as you’re doing here - the array could be of length zero, which would result in a TypeScript compiler error. You can handle the above safely using Tuples, coupled with Array destructuring instead of Array.slice(). Typescript accepts destructuring, because it statically (pre-runtime) assigns specific indices of the array to specific variables. TypeScript rejects slice(), because by definition it returns an arbitrary portion of the array. (To understand why, here’s something messed up: JavaScript runtime actually accepts Array.slice(NaN), or Array.slice(0, -Infinity) without throwing an error, so it would be very nonsensical for TypeScript to try to statically infer type from such an absurd function.)
• Example 2: In your specific case where you split arguments of any type, you can use the unknown type instead. TypeScript treats unknown types, unlike any types, as basically useless until their type is verified. (In your case, your linter throws an error, but without your linter, TypeScript would happily allow let a: any[] = []; let b = [...a]. However, TypeScript does allow an unknown to be passed to a function that accepts a type of any, e.g. console.log(...args: any[]).

Examples

1. General

function Input(
  a: string,
  b: number,
  c: boolean | unknown,
  ...whatever: unknown[],
) {
  // body
}

function ProcessFirst(
  a: string,
) {
  // body
}

function ProcessRest(
  b: number,
  ...whateverOrC: unknown[],
) {
  // body
}

/**
 * Because Input has three named arguments,
 * Parameter<typeof Input> gives a Tuple type:
 *
 * inputs: [
 *   string,
 *   number,
 *   boolean | unknown,
 *   ...unknown[]
 * ]
 */
const Processor = (
  ...inputs: Parameters<typeof Input>,
) => {

  // ProcessFirst: ([string]) => {}
  ProcessFirst(
    inputs[0], // OK: TypeScript knows this is string
  );

  // ProcessRest: ([number, ...unknown[]]) => {}
  // Use array destructuring to get inputs[1] and inputs.slice(2):
  const [ , b, ...whateverOrC] = inputs; // first ',' skips inputs[0]

  ProcessRest(
    b, // OK: TypeScript knows this is number
    ...whateverOrC, // OK: TypeScript knows this is [boolean | unknown, ...unknown[]]
      // -> boolean | unknown extends unknown
      // -> [boolean | unknown, ...unknown[]] extends [unknown, ...unknown[]]
      // -> [unknown, ...unknown[]] extends unknown[]
      // Therefore, whateverOrC extends unknown[]
  );

  return;
}

2. Your Case

const log = (
  ...args: [unknown, ...unknown[]]
) => {
  const [first, ...rest] = args;

  // console[`log`]: (any[]) => {}
  console.log(
    `foo: ${first}`, // OK: TypeScript knows first is unknown extends any
    ...rest, // OK: TypeScript knows rest is unknown[] extends any[]
  );
}

// log: ([unknown, ...unknown[]]) => {}
log(5, null); // OK:    [number, {}]
log(5);       // OK:    [number]
log();        // ERROR: [] 
log(...[]);   // ERROR: []