(function (Prism) {
  var expressionDef = /\{[^\r\n\[\]{}]*\}/;

  var params = {
    'quoted-string': {
      pattern: /"(?:[^"\\]|\\.)*"/,
      alias: 'operator',
    },
    'command-param-id': {
      pattern: /(\s)\w+:/,
      lookbehind: true,
      alias: 'property',
    },
    'command-param-value': [
      {
        pattern: expressionDef,
        alias: 'selector',
      },
      {
        pattern: /([\t ])\S+/,
        lookbehind: true,
        greedy: true,
        alias: 'operator',
      },
      {
        pattern: /\S(?:.*\S)?/,
        alias: 'operator',
      },
    ],
  };

  Prism.languages.naniscript = {
    // ; ...
    comment: {
      pattern: /^([\t ]*);.*/m,
      lookbehind: true,
    },
    // > ...
    // Define is a control line starting with '>' followed by a word, a space and a text.
    define: {
      pattern: /^>.+/m,
      alias: 'tag',
      inside: {
        value: {
          pattern: /(^>\w+[\t ]+)(?!\s)[^{}\r\n]+/,
          lookbehind: true,
          alias: 'operator',
        },
        key: {
          pattern: /(^>)\w+/,
          lookbehind: true,
        },
      },
    },
    // # ...
    label: {
      pattern: /^([\t ]*)#[\t ]*\w+[\t ]*$/m,
      lookbehind: true,
      alias: 'regex',
    },
    command: {
      pattern: /^([\t ]*)@\w+(?=[\t ]|$).*/m,
      lookbehind: true,
      alias: 'function',
      inside: {
        'command-name': /^@\w+/,
        expression: {
          pattern: expressionDef,
          greedy: true,
          alias: 'selector',
        },
        'command-params': {
          pattern: /\s*\S[\s\S]*/,
          inside: params,
        },
      },
    },
    // Generic is any line that doesn't start with operators: ;>#@
    'generic-text': {
      pattern: /(^[ \t]*)[^#@>;\s].*/m,
      lookbehind: true,
      alias: 'punctuation',
      inside: {
        // \{ ... \} ... \[ ... \] ... \"
        'escaped-char': /\\[{}\[\]"]/,
        expression: {
          pattern: expressionDef,
          greedy: true,
          alias: 'selector',
        },
        'inline-command': {
          pattern: /\[[\t ]*\w[^\r\n\[\]]*\]/,
          greedy: true,
          alias: 'function',
          inside: {
            'command-params': {
              pattern: /(^\[[\t ]*\w+\b)[\s\S]+(?=\]$)/,
              lookbehind: true,
              inside: params,
            },
            'command-param-name': {
              pattern: /^(\[[\t ]*)\w+/,
              lookbehind: true,
              alias: 'name',
            },
            'start-stop-char': /[\[\]]/,
          },
        },
      },
    },
  };
  Prism.languages.nani = Prism.languages['naniscript'];

  /** @typedef {InstanceType<import("./prism-core")["Token"]>} Token */

  /**
   * This hook is used to validate generic-text tokens for balanced brackets.
   * Mark token as bad-line when contains not balanced brackets: {},[]
   */
  Prism.hooks.add('after-tokenize', function (env) {
    /** @type {(Token | string)[]} */
    var tokens = env.tokens;
    tokens.forEach(function (token) {
      if (typeof token !== 'string' && token.type === 'generic-text') {
        var content = getTextContent(token);
        if (!isBracketsBalanced(content)) {
          token.type = 'bad-line';
          token.content = content;
        }
      }
    });
  });

  /**
   * @param {string} input
   * @returns {boolean}
   */
  function isBracketsBalanced(input) {
    var brackets = '[]{}';
    var stack = [];
    for (var i = 0; i < input.length; i++) {
      var bracket = input[i];
      var bracketsIndex = brackets.indexOf(bracket);
      if (bracketsIndex !== -1) {
        if (bracketsIndex % 2 === 0) {
          stack.push(bracketsIndex + 1);
        } else if (stack.pop() !== bracketsIndex) {
          return false;
        }
      }
    }
    return stack.length === 0;
  }

  /**
   * @param {string | Token | (string | Token)[]} token
   * @returns {string}
   */
  function getTextContent(token) {
    if (typeof token === 'string') {
      return token;
    } else if (Array.isArray(token)) {
      return token.map(getTextContent).join('');
    } else {
      return getTextContent(token.content);
    }
  }
})(Prism);