# code-block-pro/1.13.0/src/util/arrayHelpers.ts

Code Block Pro – Beautiful Syntax Highlighting, version 1.13.0. 48 lines.

- Page: https://pluginprobe.com/plugins/code-block-pro/1.13.0/code/src/util/arrayHelpers.ts
- Raw: https://pluginprobe.com/plugins/code-block-pro/1.13.0/raw/src/util/arrayHelpers.ts
- Modified: 2022-11-21T03:47:00+00:00

Line numbers below start at 1. Link to a line or a range by appending a fragment to the
page URL, for example `https://pluginprobe.com/plugins/code-block-pro/1.13.0/code/src/util/arrayHelpers.ts#L10-L20`.

```typescript
export const parseJSONArrayWithRanges = (
    lineNumbers: string,
    startingLineNumber: string,
) => {
    try {
        return (
            JSON.parse(`[${lineNumbers ?? ''}]`)
                .map((inner: number | number[]) => {
                    // offset by startingLineNumber
                    const offset = isNaN(Number(startingLineNumber))
                        ? 0
                        : Math.max(Number(startingLineNumber) - 1, 0);
                    // incoming might look like 1, 3, or [4, 8]
                    if (typeof inner === 'number') return inner - offset;
                    return Array.from(
                        { length: inner[1] - inner[0] + 1 },
                        (_, i) => inner[0] + i - offset,
                    );
                })
                // filter out empty arrays
                .filter((inner: number | number[]) =>
                    Array.isArray(inner) ? inner?.length > 0 : true,
                )
                .flat()
                // filter out negative numbers
                .filter((inner: number) => inner >= 0)
        );
    } catch (e) {
        return [];
    }
};

export const parseStringArrayWithSingleNestedArray = (lineNumbers?: string) => {
    const nums = JSON.parse(`[${lineNumbers ?? ''}]`);
    // Checking for nested arrays
    const nested = nums.filter((n: number | number[]) => Array.isArray(n));
    const doubly = nested.some((n: number[]) =>
        n.some((k) => Array.isArray(k)),
    );
    if (doubly) {
        throw new Error('Nested arrays not allowed');
    }
    if (nested.some((n: number[]) => n[0] >= n[1])) {
        throw new Error('Nested arrays must be in order');
    }
    return true;
};

```