How to use the @sqs/jsonc-parser.parse function in @sqs/jsonc-parser

}

    const totalAdditions = calculateDiff('added')
    const totalDeletions = calculateDiff('deleted')

    const status = campaign
        ? campaign.__typename === 'CampaignPlan'
            ? campaign.status
            : campaign.changesetCreationStatus
        : null

    const currentSpec = campaign && campaign.__typename === 'CampaignPlan' ? parseJSONC(campaign.arguments) : undefined
    // Tracks if a refresh of the campaignPlan is required before the campaign can be created
    const previewRefreshNeeded =
        !currentSpec ||
        (campaignPlanArguments && !isEqual(currentSpec, parseJSONC(campaignPlanArguments))) ||
        (status && status.state !== GQL.BackgroundProcessState.COMPLETED)

    return (
        <>
            
            <form>
                <div>
                    <h2>
                        </h2></div></form>

function getExternalURLPlaceholders(config: string): { externalURL: string; externalURLRegexp: string } {
    let externalURL
    let externalURLRegexp
    try {
        externalURL = jsonc.parse(config).externalURL
        externalURLRegexp = externalURL.replace(/\//g, '\\/')
    } catch {
        /* not necessarily an error, config might be empty */
    }
    if (!externalURL) {
        externalURL = ''
        externalURLRegexp = ''
    }
    return { externalURL, externalURLRegexp }
}

export async function createAuthProvider(
    gqlClient: GraphQLClient,
    authProvider: GitHubAuthProvider | GitLabAuthProvider | OpenIDConnectAuthProvider | SAMLAuthProvider
): Promise {
    const siteConfig = await fetchSiteConfiguration(gqlClient).toPromise()
    const siteConfigParsed: SiteConfiguration = jsonc.parse(siteConfig.configuration.effectiveContents)
    const authProviders = siteConfigParsed['auth.providers']
    if (
        authProviders &&
        authProviders.filter(p => p.type === authProvider.type && (p as any).displayName === authProvider.displayName)
            .length > 0
    ) {
        return () => Promise.resolve() // provider already exists
    }
    const editFns = [
        (contents: string) =>
            jsoncEdit.setProperty(contents, ['auth.providers', -1], authProvider, {
                eol: '\n',
                insertSpaces: true,
                tabSize: 2,
            }),
    ]

let services = externalServicesByKind[kind]
                        if (!services) {
                            services = []
                            externalServicesByKind[kind] = services
                        }
                        services.push(config)
                        return externalServicesByKind
                    },
                    {}
                )
            const settingsSubjects = data.viewerSettings.subjects.map(settings => ({
                __typename: settings.__typename,
                settingsURL: settings.settingsURL,
                contents: settings.latestSettings ? parseJSONC(settings.latestSettings.contents) : null,
            }))
            const finalSettings = parseJSONC(data.viewerSettings.final)
            return {
                site:
                    data.site &&
                    data.site.configuration &&
                    data.site.configuration.effectiveContents &&
                    parseJSONC(data.site.configuration.effectiveContents),
                externalServices,
                settings: {
                    subjects: settingsSubjects,
                    final: finalSettings,
                },
            }
        })
    )

export function parseJSON(text: string): any {
    const errors: ParseError[] = []
    const o = parse(text, errors, { allowTrailingComma: true, disallowComments: false })
    if (errors.length > 0) {
        throw createAggregateError(
            errors.map(v => ({
                ...v,
                code: ParseErrorCode[v.error],
                message: `Parse error, code: ${v.error} (offset: ${v.offset}, length: ${v.length})`,
            }))
        )
    }
    return o
}

export function parseJSON(text: string): any {
    const errors: ParseError[] = []
    const o = parse(text, errors, { allowTrailingComma: true, disallowComments: false })
    if (errors.length > 0) {
        throw createAggregateError(
            errors.map(v => ({
                ...v,
                code: ParseErrorCode[v.error],
                message: `Configuration parse error, code: ${v.error} (offset: ${v.offset}, length: ${v.length})`,
            }))
        )
    }
    return o
}

        map(clientSettingsString => parseJSONC(clientSettingsString || '')),
        map(clientSettings => ({

    map(clientSettingsString => JSONC.parse(clientSettingsString)),
    map(clientSettings => ({

                .map((svc): [GQL.ExternalServiceKind, ExternalServiceConfig] => [svc.kind, parseJSONC(svc.config)])
                .reduce>(