@glimmer/syntax/dist/modules/es2017/lib/v2-a/normalize.js

import { assert, assign, isPresent } from '@glimmer/util';
import Printer from '../generation/printer';
import { preprocess } from '../parser/tokenizer-event-handlers';
import { SourceSlice } from '../source/slice';
import { SpanList } from '../source/span-list';
import { SymbolTable } from '../symbol-table';
import { generateSyntaxError } from '../syntax-error';
import { isLowerCase, isUpperCase } from '../utils';
import b from '../v1/parser-builders';
import * as ASTv2 from './api';
import { Builder } from './builders';
import { AppendSyntaxContext, AttrValueSyntaxContext, BlockSyntaxContext, ComponentSyntaxContext, ModifierSyntaxContext, SexpSyntaxContext } from './loose-resolution';
export function normalize(source, options = {}) {
  var _a;

  let ast = preprocess(source, options);
  let normalizeOptions = assign({
    strictMode: false,
    locals: []
  }, options);
  let top = SymbolTable.top(normalizeOptions.locals, (_a = // eslint-disable-next-line @typescript-eslint/unbound-method
  options.customizeComponentName) !== null && _a !== void 0 ? _a : name => name);
  let block = new BlockContext(source, normalizeOptions, top);
  let normalizer = new StatementNormalizer(block);
  let astV2 = new TemplateChildren(block.loc(ast.loc), ast.body.map(b => normalizer.normalize(b)), block).assertTemplate(top);
  let locals = top.getUsedTemplateLocals();
  return [astV2, locals];
}
/**
 * A `BlockContext` represents the block that a particular AST node is contained inside of.
 *
 * `BlockContext` is aware of template-wide options (such as strict mode), as well as the bindings
 * that are in-scope within that block.
 *
 * Concretely, it has the `PrecompileOptions` and current `SymbolTable`, and provides
 * facilities for working with those options.
 *
 * `BlockContext` is stateless.
 */

export class BlockContext {
  constructor(source, options, table) {
    this.source = source;
    this.options = options;
    this.table = table;
    this.builder = new Builder();
  }

  get strict() {
    return this.options.strictMode || false;
  }

  loc(loc) {
    return this.source.spanFor(loc);
  }

  resolutionFor(node, resolution) {
    if (this.strict) {
      return {
        resolution: ASTv2.STRICT_RESOLUTION
      };
    }

    if (this.isFreeVar(node)) {
      let r = resolution(node);

      if (r === null) {
        return {
          resolution: 'error',
          path: printPath(node),
          head: printHead(node)
        };
      }

      return {
        resolution: r
      };
    } else {
      return {
        resolution: ASTv2.STRICT_RESOLUTION
      };
    }
  }

  isFreeVar(callee) {
    if (callee.type === 'PathExpression') {
      if (callee.head.type !== 'VarHead') {
        return false;
      }

      return !this.table.has(callee.head.name);
    } else if (callee.path.type === 'PathExpression') {
      return this.isFreeVar(callee.path);
    } else {
      return false;
    }
  }

  hasBinding(name) {
    return this.table.has(name);
  }

  child(blockParams) {
    return new BlockContext(this.source, this.options, this.table.child(blockParams));
  }

  customizeComponentName(input) {
    if (this.options.customizeComponentName) {
      return this.options.customizeComponentName(input);
    } else {
      return input;
    }
  }

}
/**
 * An `ExpressionNormalizer` normalizes expressions within a block.
 *
 * `ExpressionNormalizer` is stateless.
 */

class ExpressionNormalizer {
  constructor(block) {
    this.block = block;
  }

  normalize(expr, resolution) {
    switch (expr.type) {
      case 'NullLiteral':
      case 'BooleanLiteral':
      case 'NumberLiteral':
      case 'StringLiteral':
      case 'UndefinedLiteral':
        return this.block.builder.literal(expr.value, this.block.loc(expr.loc));

      case 'PathExpression':
        return this.path(expr, resolution);

      case 'SubExpression':
        {
          let resolution = this.block.resolutionFor(expr, SexpSyntaxContext);

          if (resolution.resolution === 'error') {
            throw generateSyntaxError(`You attempted to invoke a path (\`${resolution.path}\`) but ${resolution.head} was not in scope`, expr.loc);
          }

          return this.block.builder.sexp(this.callParts(expr, resolution.resolution), this.block.loc(expr.loc));
        }
    }
  }

  path(expr, resolution) {
    let headOffsets = this.block.loc(expr.head.loc);
    let tail = []; // start with the head

    let offset = headOffsets;

    for (let part of expr.tail) {
      offset = offset.sliceStartChars({
        chars: part.length,
        skipStart: 1
      });
      tail.push(new SourceSlice({
        loc: offset,
        chars: part
      }));
    }

    return this.block.builder.path(this.ref(expr.head, resolution), tail, this.block.loc(expr.loc));
  }
  /**
   * The `callParts` method takes ASTv1.CallParts as well as a syntax context and normalizes
   * it to an ASTv2 CallParts.
   */


  callParts(parts, context) {
    let {
      path,
      params,
      hash
    } = parts;
    let callee = this.normalize(path, context);
    let paramList = params.map(p => this.normalize(p, ASTv2.ARGUMENT_RESOLUTION));
    let paramLoc = SpanList.range(paramList, callee.loc.collapse('end'));
    let namedLoc = this.block.loc(hash.loc);
    let argsLoc = SpanList.range([paramLoc, namedLoc]);
    let positional = this.block.builder.positional(params.map(p => this.normalize(p, ASTv2.ARGUMENT_RESOLUTION)), paramLoc);
    let named = this.block.builder.named(hash.pairs.map(p => this.namedArgument(p)), this.block.loc(hash.loc));
    return {
      callee,
      args: this.block.builder.args(positional, named, argsLoc)
    };
  }

  namedArgument(pair) {
    let offsets = this.block.loc(pair.loc);
    let keyOffsets = offsets.sliceStartChars({
      chars: pair.key.length
    });
    return this.block.builder.namedArgument(new SourceSlice({
      chars: pair.key,
      loc: keyOffsets
    }), this.normalize(pair.value, ASTv2.ARGUMENT_RESOLUTION));
  }
  /**
   * The `ref` method normalizes an `ASTv1.PathHead` into an `ASTv2.VariableReference`.
   * This method is extremely important, because it is responsible for normalizing free
   * variables into an an ASTv2.PathHead *with appropriate context*.
   *
   * The syntax context is originally determined by the syntactic position that this `PathHead`
   * came from, and is ultimately attached to the `ASTv2.VariableReference` here. In ASTv2,
   * the `VariableReference` node bears full responsibility for loose mode rules that control
   * the behavior of free variables.
   */


  ref(head, resolution) {
    let {
      block
    } = this;
    let {
      builder,
      table
    } = block;
    let offsets = block.loc(head.loc);

    switch (head.type) {
      case 'ThisHead':
        return builder.self(offsets);

      case 'AtHead':
        {
          let symbol = table.allocateNamed(head.name);
          return builder.at(head.name, symbol, offsets);
        }

      case 'VarHead':
        {
          if (block.hasBinding(head.name)) {
            let [symbol, isRoot] = table.get(head.name);
            return block.builder.localVar(head.name, symbol, isRoot, offsets);
          } else {
            let context = block.strict ? ASTv2.STRICT_RESOLUTION : resolution;
            let symbol = block.table.allocateFree(head.name, context);
            return block.builder.freeVar({
              name: head.name,
              context,
              symbol,
              loc: offsets
            });
          }
        }
    }
  }

}
/**
 * `TemplateNormalizer` normalizes top-level ASTv1 statements to ASTv2.
 */


class StatementNormalizer {
  constructor(block) {
    this.block = block;
  }

  normalize(node) {
    switch (node.type) {
      case 'PartialStatement':
        throw new Error(`Handlebars partial syntax ({{> ...}}) is not allowed in Glimmer`);

      case 'BlockStatement':
        return this.BlockStatement(node);

      case 'ElementNode':
        return new ElementNormalizer(this.block).ElementNode(node);

      case 'MustacheStatement':
        return this.MustacheStatement(node);
      // These are the same in ASTv2

      case 'MustacheCommentStatement':
        return this.MustacheCommentStatement(node);

      case 'CommentStatement':
        {
          let loc = this.block.loc(node.loc);
          return new ASTv2.HtmlComment({
            loc,
            text: loc.slice({
              skipStart: 4,
              skipEnd: 3
            }).toSlice(node.value)
          });
        }

      case 'TextNode':
        return new ASTv2.HtmlText({
          loc: this.block.loc(node.loc),
          chars: node.chars
        });
    }
  }

  MustacheCommentStatement(node) {
    let loc = this.block.loc(node.loc);
    let textLoc;

    if (loc.asString().slice(0, 5) === '{{!--') {
      textLoc = loc.slice({
        skipStart: 5,
        skipEnd: 4
      });
    } else {
      textLoc = loc.slice({
        skipStart: 3,
        skipEnd: 2
      });
    }

    return new ASTv2.GlimmerComment({
      loc,
      text: textLoc.toSlice(node.value)
    });
  }
  /**
   * Normalizes an ASTv1.MustacheStatement to an ASTv2.AppendStatement
   */


  MustacheStatement(mustache) {
    let {
      escaped
    } = mustache;
    let loc = this.block.loc(mustache.loc); // Normalize the call parts in AppendSyntaxContext

    let callParts = this.expr.callParts({
      path: mustache.path,
      params: mustache.params,
      hash: mustache.hash
    }, AppendSyntaxContext(mustache));
    let value = callParts.args.isEmpty() ? callParts.callee : this.block.builder.sexp(callParts, loc);
    return this.block.builder.append({
      table: this.block.table,
      trusting: !escaped,
      value
    }, loc);
  }
  /**
   * Normalizes a ASTv1.BlockStatement to an ASTv2.BlockStatement
   */


  BlockStatement(block) {
    let {
      program,
      inverse
    } = block;
    let loc = this.block.loc(block.loc);
    let resolution = this.block.resolutionFor(block, BlockSyntaxContext);

    if (resolution.resolution === 'error') {
      throw generateSyntaxError(`You attempted to invoke a path (\`{{#${resolution.path}}}\`) but ${resolution.head} was not in scope`, loc);
    }

    let callParts = this.expr.callParts(block, resolution.resolution);
    return this.block.builder.blockStatement(assign({
      symbols: this.block.table,
      program: this.Block(program),
      inverse: inverse ? this.Block(inverse) : null
    }, callParts), loc);
  }

  Block({
    body,
    loc,
    blockParams
  }) {
    let child = this.block.child(blockParams);
    let normalizer = new StatementNormalizer(child);
    return new BlockChildren(this.block.loc(loc), body.map(b => normalizer.normalize(b)), this.block).assertBlock(child.table);
  }

  get expr() {
    return new ExpressionNormalizer(this.block);
  }

}

class ElementNormalizer {
  constructor(ctx) {
    this.ctx = ctx;
  }
  /**
   * Normalizes an ASTv1.ElementNode to:
   *
   * - ASTv2.NamedBlock if the tag name begins with `:`
   * - ASTv2.Component if the tag name matches the component heuristics
   * - ASTv2.SimpleElement if the tag name doesn't match the component heuristics
   *
   * A tag name represents a component if:
   *
   * - it begins with `@`
   * - it is exactly `this` or begins with `this.`
   * - the part before the first `.` is a reference to an in-scope variable binding
   * - it begins with an uppercase character
   */


  ElementNode(element) {
    let {
      tag,
      selfClosing,
      comments
    } = element;
    let loc = this.ctx.loc(element.loc);
    let [tagHead, ...rest] = tag.split('.'); // the head, attributes and modifiers are in the current scope

    let path = this.classifyTag(tagHead, rest, element.loc);
    let attrs = element.attributes.filter(a => a.name[0] !== '@').map(a => this.attr(a));
    let args = element.attributes.filter(a => a.name[0] === '@').map(a => this.arg(a));
    let modifiers = element.modifiers.map(m => this.modifier(m)); // the element's block params are in scope for the children

    let child = this.ctx.child(element.blockParams);
    let normalizer = new StatementNormalizer(child);
    let childNodes = element.children.map(s => normalizer.normalize(s));
    let el = this.ctx.builder.element({
      selfClosing,
      attrs,
      componentArgs: args,
      modifiers,
      comments: comments.map(c => new StatementNormalizer(this.ctx).MustacheCommentStatement(c))
    });
    let children = new ElementChildren(el, loc, childNodes, this.ctx);
    let offsets = this.ctx.loc(element.loc);
    let tagOffsets = offsets.sliceStartChars({
      chars: tag.length,
      skipStart: 1
    });

    if (path === 'ElementHead') {
      if (tag[0] === ':') {
        return children.assertNamedBlock(tagOffsets.slice({
          skipStart: 1
        }).toSlice(tag.slice(1)), child.table);
      } else {
        return children.assertElement(tagOffsets.toSlice(tag), element.blockParams.length > 0);
      }
    }

    if (element.selfClosing) {
      return el.selfClosingComponent(path, loc);
    } else {
      let blocks = children.assertComponent(tag, child.table, element.blockParams.length > 0);
      return el.componentWithNamedBlocks(path, blocks, loc);
    }
  }

  modifier(m) {
    let resolution = this.ctx.resolutionFor(m, ModifierSyntaxContext);

    if (resolution.resolution === 'error') {
      throw generateSyntaxError(`You attempted to invoke a path (\`{{#${resolution.path}}}\`) as a modifier, but ${resolution.head} was not in scope. Try adding \`this\` to the beginning of the path`, m.loc);
    }

    let callParts = this.expr.callParts(m, resolution.resolution);
    return this.ctx.builder.modifier(callParts, this.ctx.loc(m.loc));
  }
  /**
   * This method handles attribute values that are curlies, as well as curlies nested inside of
   * interpolations:
   *
   * ```hbs
   * <a href={{url}} />
   * <a href="{{url}}.html" />
   * ```
   */


  mustacheAttr(mustache) {
    // Normalize the call parts in AttrValueSyntaxContext
    let sexp = this.ctx.builder.sexp(this.expr.callParts(mustache, AttrValueSyntaxContext(mustache)), this.ctx.loc(mustache.loc)); // If there are no params or hash, just return the function part as its own expression

    if (sexp.args.isEmpty()) {
      return sexp.callee;
    } else {
      return sexp;
    }
  }
  /**
   * attrPart is the narrowed down list of valid attribute values that are also
   * allowed as a concat part (you can't nest concats).
   */


  attrPart(part) {
    switch (part.type) {
      case 'MustacheStatement':
        return {
          expr: this.mustacheAttr(part),
          trusting: !part.escaped
        };

      case 'TextNode':
        return {
          expr: this.ctx.builder.literal(part.chars, this.ctx.loc(part.loc)),
          trusting: true
        };
    }
  }

  attrValue(part) {
    switch (part.type) {
      case 'ConcatStatement':
        {
          let parts = part.parts.map(p => this.attrPart(p).expr);
          return {
            expr: this.ctx.builder.interpolate(parts, this.ctx.loc(part.loc)),
            trusting: false
          };
        }

      default:
        return this.attrPart(part);
    }
  }

  attr(m) {
    (false && assert(m.name[0] !== '@', 'An attr name must not start with `@`'));

    if (m.name === '...attributes') {
      return this.ctx.builder.splatAttr(this.ctx.table.allocateBlock('attrs'), this.ctx.loc(m.loc));
    }

    let offsets = this.ctx.loc(m.loc);
    let nameSlice = offsets.sliceStartChars({
      chars: m.name.length
    }).toSlice(m.name);
    let value = this.attrValue(m.value);
    return this.ctx.builder.attr({
      name: nameSlice,
      value: value.expr,
      trusting: value.trusting
    }, offsets);
  }

  maybeDeprecatedCall(arg, part) {
    if (this.ctx.strict) {
      return null;
    }

    if (part.type !== 'MustacheStatement') {
      return null;
    }

    let {
      path
    } = part;

    if (path.type !== 'PathExpression') {
      return null;
    }

    if (path.head.type !== 'VarHead') {
      return null;
    }

    let {
      name
    } = path.head;

    if (name === 'has-block' || name === 'has-block-params') {
      return null;
    }

    if (this.ctx.hasBinding(name)) {
      return null;
    }

    if (path.tail.length !== 0) {
      return null;
    }

    if (part.params.length !== 0 || part.hash.pairs.length !== 0) {
      return null;
    }

    let context = ASTv2.LooseModeResolution.attr();
    let callee = this.ctx.builder.freeVar({
      name,
      context,
      symbol: this.ctx.table.allocateFree(name, context),
      loc: path.loc
    });
    return {
      expr: this.ctx.builder.deprecatedCall(arg, callee, part.loc),
      trusting: false
    };
  }

  arg(arg) {
    (false && assert(arg.name[0] === '@', 'An arg name must start with `@`'));
    let offsets = this.ctx.loc(arg.loc);
    let nameSlice = offsets.sliceStartChars({
      chars: arg.name.length
    }).toSlice(arg.name);
    let value = this.maybeDeprecatedCall(nameSlice, arg.value) || this.attrValue(arg.value);
    return this.ctx.builder.arg({
      name: nameSlice,
      value: value.expr,
      trusting: value.trusting
    }, offsets);
  }
  /**
   * This function classifies the head of an ASTv1.Element into an ASTv2.PathHead (if the
   * element is a component) or `'ElementHead'` (if the element is a simple element).
   *
   * Rules:
   *
   * 1. If the variable is an `@arg`, return an `AtHead`
   * 2. If the variable is `this`, return a `ThisHead`
   * 3. If the variable is in the current scope:
   *   a. If the scope is the root scope, then return a Free `LocalVarHead`
   *   b. Else, return a standard `LocalVarHead`
   * 4. If the tag name is a path and the variable is not in the current scope, Syntax Error
   * 5. If the variable is uppercase return a FreeVar(ResolveAsComponentHead)
   * 6. Otherwise, return `'ElementHead'`
   */


  classifyTag(variable, tail, loc) {
    let uppercase = isUpperCase(variable);
    let inScope = variable[0] === '@' || variable === 'this' || this.ctx.hasBinding(variable);

    if (this.ctx.strict && !inScope) {
      if (uppercase) {
        throw generateSyntaxError(`Attempted to invoke a component that was not in scope in a strict mode template, \`<${variable}>\`. If you wanted to create an element with that name, convert it to lowercase - \`<${variable.toLowerCase()}>\``, loc);
      } // In strict mode, values are always elements unless they are in scope


      return 'ElementHead';
    } // Since the parser handed us the HTML element name as a string, we need
    // to convert it into an ASTv1 path so it can be processed using the
    // expression normalizer.


    let isComponent = inScope || uppercase;
    let variableLoc = loc.sliceStartChars({
      skipStart: 1,
      chars: variable.length
    });
    let tailLength = tail.reduce((accum, part) => accum + 1 + part.length, 0);
    let pathEnd = variableLoc.getEnd().move(tailLength);
    let pathLoc = variableLoc.withEnd(pathEnd);

    if (isComponent) {
      let path = b.path({
        head: b.head(variable, variableLoc),
        tail,
        loc: pathLoc
      });
      let resolution = this.ctx.resolutionFor(path, ComponentSyntaxContext);

      if (resolution.resolution === 'error') {
        throw generateSyntaxError(`You attempted to invoke a path (\`<${resolution.path}>\`) but ${resolution.head} was not in scope`, loc);
      }

      return new ExpressionNormalizer(this.ctx).normalize(path, resolution.resolution);
    } // If the tag name wasn't a valid component but contained a `.`, it's
    // a syntax error.


    if (tail.length > 0) {
      throw generateSyntaxError(`You used ${variable}.${tail.join('.')} as a tag name, but ${variable} is not in scope`, loc);
    }

    return 'ElementHead';
  }

  get expr() {
    return new ExpressionNormalizer(this.ctx);
  }

}

class Children {
  constructor(loc, children, block) {
    this.loc = loc;
    this.children = children;
    this.block = block;
    this.namedBlocks = children.filter(c => c instanceof ASTv2.NamedBlock);
    this.hasSemanticContent = Boolean(children.filter(c => {
      if (c instanceof ASTv2.NamedBlock) {
        return false;
      }

      switch (c.type) {
        case 'GlimmerComment':
        case 'HtmlComment':
          return false;

        case 'HtmlText':
          return !/^\s*$/.exec(c.chars);

        default:
          return true;
      }
    }).length);
    this.nonBlockChildren = children.filter(c => !(c instanceof ASTv2.NamedBlock));
  }

}

class TemplateChildren extends Children {
  assertTemplate(table) {
    if (isPresent(this.namedBlocks)) {
      throw generateSyntaxError(`Unexpected named block at the top-level of a template`, this.loc);
    }

    return this.block.builder.template(table, this.nonBlockChildren, this.block.loc(this.loc));
  }

}

class BlockChildren extends Children {
  assertBlock(table) {
    if (isPresent(this.namedBlocks)) {
      throw generateSyntaxError(`Unexpected named block nested in a normal block`, this.loc);
    }

    return this.block.builder.block(table, this.nonBlockChildren, this.loc);
  }

}

class ElementChildren extends Children {
  constructor(el, loc, children, block) {
    super(loc, children, block);
    this.el = el;
  }

  assertNamedBlock(name, table) {
    if (this.el.base.selfClosing) {
      throw generateSyntaxError(`<:${name.chars}/> is not a valid named block: named blocks cannot be self-closing`, this.loc);
    }

    if (isPresent(this.namedBlocks)) {
      throw generateSyntaxError(`Unexpected named block inside <:${name.chars}> named block: named blocks cannot contain nested named blocks`, this.loc);
    }

    if (!isLowerCase(name.chars)) {
      throw generateSyntaxError(`<:${name.chars}> is not a valid named block, and named blocks must begin with a lowercase letter`, this.loc);
    }

    if (this.el.base.attrs.length > 0 || this.el.base.componentArgs.length > 0 || this.el.base.modifiers.length > 0) {
      throw generateSyntaxError(`named block <:${name.chars}> cannot have attributes, arguments, or modifiers`, this.loc);
    }

    let offsets = SpanList.range(this.nonBlockChildren, this.loc);
    return this.block.builder.namedBlock(name, this.block.builder.block(table, this.nonBlockChildren, offsets), this.loc);
  }

  assertElement(name, hasBlockParams) {
    if (hasBlockParams) {
      throw generateSyntaxError(`Unexpected block params in <${name}>: simple elements cannot have block params`, this.loc);
    }

    if (isPresent(this.namedBlocks)) {
      let names = this.namedBlocks.map(b => b.name);

      if (names.length === 1) {
        throw generateSyntaxError(`Unexpected named block <:foo> inside <${name.chars}> HTML element`, this.loc);
      } else {
        let printedNames = names.map(n => `<:${n.chars}>`).join(', ');
        throw generateSyntaxError(`Unexpected named blocks inside <${name.chars}> HTML element (${printedNames})`, this.loc);
      }
    }

    return this.el.simple(name, this.nonBlockChildren, this.loc);
  }

  assertComponent(name, table, hasBlockParams) {
    if (isPresent(this.namedBlocks) && this.hasSemanticContent) {
      throw generateSyntaxError(`Unexpected content inside <${name}> component invocation: when using named blocks, the tag cannot contain other content`, this.loc);
    }

    if (isPresent(this.namedBlocks)) {
      if (hasBlockParams) {
        throw generateSyntaxError(`Unexpected block params list on <${name}> component invocation: when passing named blocks, the invocation tag cannot take block params`, this.loc);
      }

      let seenNames = new Set();

      for (let block of this.namedBlocks) {
        let name = block.name.chars;

        if (seenNames.has(name)) {
          throw generateSyntaxError(`Component had two named blocks with the same name, \`<:${name}>\`. Only one block with a given name may be passed`, this.loc);
        }

        if (name === 'inverse' && seenNames.has('else') || name === 'else' && seenNames.has('inverse')) {
          throw generateSyntaxError(`Component has both <:else> and <:inverse> block. <:inverse> is an alias for <:else>`, this.loc);
        }

        seenNames.add(name);
      }

      return this.namedBlocks;
    } else {
      return [this.block.builder.namedBlock(SourceSlice.synthetic('default'), this.block.builder.block(table, this.nonBlockChildren, this.loc), this.loc)];
    }
  }

}

function printPath(node) {
  if (node.type !== 'PathExpression' && node.path.type === 'PathExpression') {
    return printPath(node.path);
  } else {
    return new Printer({
      entityEncoding: 'raw'
    }).print(node);
  }
}

function printHead(node) {
  if (node.type === 'PathExpression') {
    switch (node.head.type) {
      case 'AtHead':
      case 'VarHead':
        return node.head.name;

      case 'ThisHead':
        return 'this';
    }
  } else if (node.path.type === 'PathExpression') {
    return printHead(node.path);
  } else {
    return new Printer({
      entityEncoding: 'raw'
    }).print(node);
  }
}
//# sourceMappingURL=data:application/json;charset=utf-8;base64,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